@ohos-ports/nx 19.8.4-beta.0

package/src/plugins/js/package-json/create-package-json.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageJson = createPackageJson;
+exports.findProjectsNpmDependencies = findProjectsNpmDependencies;
+const fileutils_1 = require("../../../utils/fileutils");
+const object_sort_1 = require("../../../utils/object-sort");
+const project_graph_1 = require("../../../config/project-graph");
+const fs_1 = require("fs");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const configuration_1 = require("../../../config/configuration");
+const nx_deps_cache_1 = require("../../../project-graph/nx-deps-cache");
+const path_1 = require("path");
+const task_hasher_1 = require("../../../hasher/task-hasher");
+const output_1 = require("../../../utils/output");
+/**
+ * Creates a package.json in the output directory for support to install dependencies within containers.
+ *
+ * If a package.json exists in the project, it will reuse that.
+ * If isProduction flag is set, it wil  remove devDependencies and optional peerDependencies
+ */
+function createPackageJson(projectName, graph, options = {}, fileMap = null) {
+    const projectNode = graph.nodes[projectName];
+    const isLibrary = projectNode.type === 'lib';
+    const rootPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(options.root ?? workspace_root_1.workspaceRoot, 'package.json'));
+    const npmDeps = findProjectsNpmDependencies(projectNode, graph, options.target, rootPackageJson, {
+        helperDependencies: options.helperDependencies,
+        isProduction: options.isProduction,
+    }, fileMap);
+    // default package.json if one does not exist
+    let packageJson = {
+        name: projectName,
+        version: '0.0.1',
+    };
+    const projectPackageJsonPath = (0, path_1.join)(options.root ?? workspace_root_1.workspaceRoot, projectNode.data.root, 'package.json');
+    if ((0, fs_1.existsSync)(projectPackageJsonPath)) {
+        try {
+            packageJson = (0, fileutils_1.readJsonFile)(projectPackageJsonPath);
+            // for standalone projects we don't want to include all the root dependencies
+            if (graph.nodes[projectName].data.root === '.') {
+                // TODO: We should probably think more on this - Nx can't always
+                // detect all external dependencies, and there's not a way currently
+                // to tell Nx that we need one of these deps. For non-standalone projects
+                // we tell people to add it to the package.json of the project, and we
+                // merge it. For standalone, this pattern doesn't work because of this piece of code.
+                // It breaks expectations, but also, I don't know another way around it currently.
+                // If Nx doesn't pick up a dep, say some css lib that is only imported in a .scss file,
+                // we need to be able to tell it to keep that dep in the generated package.json.
+                delete packageJson.dependencies;
+                delete packageJson.devDependencies;
+            }
+            if (options.isProduction) {
+                delete packageJson.devDependencies;
+            }
+        }
+        catch (e) { }
+    }
+    const getVersion = (packageName, version, section) => {
+        return (packageJson[section][packageName] ||
+            (isLibrary && rootPackageJson[section]?.[packageName]) ||
+            version);
+    };
+    Object.entries(npmDeps.dependencies).forEach(([packageName, version]) => {
+        if (rootPackageJson.devDependencies?.[packageName] &&
+            !packageJson.dependencies?.[packageName] &&
+            !packageJson.peerDependencies?.[packageName]) {
+            // don't store dev dependencies for production
+            if (!options.isProduction) {
+                packageJson.devDependencies ??= {};
+                packageJson.devDependencies[packageName] = getVersion(packageName, version, 'devDependencies');
+            }
+        }
+        else {
+            if (!packageJson.peerDependencies?.[packageName]) {
+                packageJson.dependencies ??= {};
+                packageJson.dependencies[packageName] = getVersion(packageName, version, 'dependencies');
+            }
+        }
+    });
+    if (!isLibrary) {
+        Object.entries(npmDeps.peerDependencies).forEach(([packageName, version]) => {
+            if (!packageJson.peerDependencies?.[packageName]) {
+                if (rootPackageJson.dependencies?.[packageName]) {
+                    packageJson.dependencies ??= {};
+                    packageJson.dependencies[packageName] = getVersion(packageName, version, 'dependencies');
+                    return;
+                }
+                const isOptionalPeer = npmDeps.peerDependenciesMeta[packageName]?.optional;
+                if (!isOptionalPeer) {
+                    if (!options.isProduction ||
+                        rootPackageJson.dependencies?.[packageName]) {
+                        packageJson.peerDependencies ??= {};
+                        packageJson.peerDependencies[packageName] = getVersion(packageName, version, 'dependencies');
+                    }
+                }
+                else if (!options.isProduction) {
+                    // add peer optional dependencies if not in production
+                    packageJson.peerDependencies ??= {};
+                    packageJson.peerDependencies[packageName] = version;
+                    packageJson.peerDependenciesMeta ??= {};
+                    packageJson.peerDependenciesMeta[packageName] = {
+                        optional: true,
+                    };
+                }
+            }
+        });
+    }
+    packageJson.devDependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.devDependencies);
+    packageJson.dependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.dependencies);
+    packageJson.peerDependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.peerDependencies);
+    packageJson.peerDependenciesMeta &&= (0, object_sort_1.sortObjectByKeys)(packageJson.peerDependenciesMeta);
+    if (rootPackageJson.packageManager && !options.skipPackageManager) {
+        if (packageJson.packageManager &&
+            packageJson.packageManager !== rootPackageJson.packageManager) {
+            output_1.output.warn({
+                title: 'Package Manager Mismatch',
+                bodyLines: [
+                    `The project ${projectName} has explicitly specified "packageManager" config of "${packageJson.packageManager}" but the workspace is using "${rootPackageJson.packageManager}".`,
+                    `Please remove the project level "packageManager" config or align it with the workspace root package.json.`,
+                ],
+            });
+        }
+        packageJson.packageManager = rootPackageJson.packageManager;
+    }
+    // region Overrides/Resolutions
+    // npm
+    if (rootPackageJson.overrides && !options.skipOverrides) {
+        packageJson.overrides = {
+            ...rootPackageJson.overrides,
+            ...packageJson.overrides,
+        };
+    }
+    // pnpm
+    if (rootPackageJson.pnpm?.overrides && !options.skipOverrides) {
+        packageJson.pnpm ??= {};
+        packageJson.pnpm.overrides = {
+            ...rootPackageJson.pnpm.overrides,
+            ...packageJson.pnpm.overrides,
+        };
+    }
+    // yarn
+    if (rootPackageJson.resolutions && !options.skipOverrides) {
+        packageJson.resolutions = {
+            ...rootPackageJson.resolutions,
+            ...packageJson.resolutions,
+        };
+    }
+    // endregion Overrides/Resolutions
+    return packageJson;
+}
+function findProjectsNpmDependencies(projectNode, graph, target, rootPackageJson, options, fileMap) {
+    if (fileMap == null) {
+        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
+    }
+    const { selfInputs, dependencyInputs } = target
+        ? (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), projectNode, target)
+        : { selfInputs: [], dependencyInputs: [] };
+    const npmDeps = {
+        dependencies: {},
+        peerDependencies: {},
+        peerDependenciesMeta: {},
+    };
+    const seen = new Set();
+    options.helperDependencies?.forEach((dep) => {
+        seen.add(dep);
+        npmDeps.dependencies[graph.externalNodes[dep].data.packageName] =
+            graph.externalNodes[dep].data.version;
+        recursivelyCollectPeerDependencies(dep, graph, npmDeps, seen);
+    });
+    // if it's production, we want to ignore all found devDependencies
+    const ignoredDependencies = options.isProduction && rootPackageJson.devDependencies
+        ? [
+            ...(options.ignoredDependencies || []),
+            ...Object.keys(rootPackageJson.devDependencies),
+        ]
+        : options.ignoredDependencies || [];
+    findAllNpmDeps(fileMap, projectNode, graph, npmDeps, seen, ignoredDependencies, dependencyInputs, selfInputs);
+    return npmDeps;
+}
+function findAllNpmDeps(projectFileMap, projectNode, graph, npmDeps, seen, ignoredDependencies, dependencyPatterns, rootPatterns) {
+    if (seen.has(projectNode.name))
+        return;
+    seen.add(projectNode.name);
+    const projectFiles = (0, task_hasher_1.filterUsingGlobPatterns)(projectNode.data.root, projectFileMap[projectNode.name] || [], rootPatterns ?? dependencyPatterns);
+    const projectDependencies = new Set();
+    projectFiles.forEach((fileData) => fileData.deps?.forEach((dep) => projectDependencies.add((0, project_graph_1.fileDataDepTarget)(dep))));
+    for (const dep of projectDependencies) {
+        const node = graph.externalNodes[dep];
+        if (seen.has(dep)) {
+            // if it's in peerDependencies, move it to regular dependencies
+            // since this is a direct dependency of the project
+            if (node && npmDeps.peerDependencies[node.data.packageName]) {
+                npmDeps.dependencies[node.data.packageName] = node.data.version;
+                delete npmDeps.peerDependencies[node.data.packageName];
+            }
+        }
+        else {
+            if (node) {
+                seen.add(dep);
+                // do not add ignored dependencies to the list or non-npm dependencies
+                if (ignoredDependencies.includes(node.data.packageName) ||
+                    node.type !== 'npm') {
+                    continue;
+                }
+                npmDeps.dependencies[node.data.packageName] = node.data.version;
+                recursivelyCollectPeerDependencies(node.name, graph, npmDeps, seen);
+            }
+            else if (graph.nodes[dep]) {
+                findAllNpmDeps(projectFileMap, graph.nodes[dep], graph, npmDeps, seen, ignoredDependencies, dependencyPatterns);
+            }
+        }
+    }
+}
+function recursivelyCollectPeerDependencies(projectName, graph, npmDeps, seen) {
+    const npmPackage = graph.externalNodes[projectName];
+    if (!npmPackage) {
+        return npmDeps;
+    }
+    const packageName = npmPackage.data.packageName;
+    try {
+        const packageJson = require(`${packageName}/package.json`);
+        if (!packageJson.peerDependencies) {
+            return npmDeps;
+        }
+        Object.keys(packageJson.peerDependencies)
+            .map((dependencyName) => `npm:${dependencyName}`)
+            .map((dependency) => graph.externalNodes[dependency])
+            .filter(Boolean)
+            .forEach((node) => {
+            if (!seen.has(node.name)) {
+                seen.add(node.name);
+                npmDeps.peerDependencies[node.data.packageName] = node.data.version;
+                if (packageJson.peerDependenciesMeta &&
+                    packageJson.peerDependenciesMeta[node.data.packageName] &&
+                    packageJson.peerDependenciesMeta[node.data.packageName].optional) {
+                    npmDeps.peerDependenciesMeta[node.data.packageName] = {
+                        optional: true,
+                    };
+                }
+                recursivelyCollectPeerDependencies(node.name, graph, npmDeps, seen);
+            }
+        });
+        return npmDeps;
+    }
+    catch (e) {
+        return npmDeps;
+    }
+}

package/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -0,0 +1,4 @@
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | JsonChange>;

package/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromLockFile = void 0;
+const configuration_1 = require("../../../../config/configuration");
+const config_1 = require("../../utils/config");
+const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
+const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    if (projectsAffectedByDependencyUpdates === 'auto') {
+        return [];
+    }
+    else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
+        return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
+    }
+    const lockFiles = [
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        'pnpm-lock.yml',
+        'bun.lockb',
+    ];
+    if (fileChanges.some((f) => lockFiles.includes(f.file))) {
+        return Object.values(projectGraphNodes).map((p) => p.name);
+    }
+    return [];
+};
+exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;

package/src/plugins/js/project-graph/affected/npm-packages.d.ts

@@ -0,0 +1,4 @@
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedNpmPackages: TouchedProjectLocator<WholeFileChange | JsonChange>;

package/src/plugins/js/project-graph/affected/npm-packages.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedNpmPackages = void 0;
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const json_diff_1 = require("../../../../utils/json-diff");
+const logger_1 = require("../../../../utils/logger");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
+const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
+    const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
+    if (!packageJsonChange)
+        return [];
+    const globalPackages = new Set(getGlobalPackages(nxJson.plugins));
+    let touched = [];
+    const changes = packageJsonChange.getChanges();
+    const npmPackages = Object.values(projectGraph.externalNodes);
+    const missingTouchedNpmPackages = [];
+    for (const c of changes) {
+        if ((0, json_diff_1.isJsonChange)(c) &&
+            (c.path[0] === 'dependencies' || c.path[0] === 'devDependencies') &&
+            c.path.length === 2) {
+            // A package was deleted so mark all workspace projects as touched.
+            if (c.type === json_diff_1.JsonDiffType.Deleted) {
+                touched = Object.keys(projectGraph.nodes);
+                break;
+            }
+            else {
+                let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1]);
+                if (!npmPackage) {
+                    // dependency can also point to a workspace project
+                    const nodes = Object.values(projectGraph.nodes);
+                    npmPackage = nodes.find((n) => n.name === c.path[1]);
+                }
+                if (!npmPackage) {
+                    missingTouchedNpmPackages.push(c.path[1]);
+                    continue;
+                }
+                touched.push(npmPackage.name);
+                // If it was a type declarations package then also mark its corresponding implementation package as affected
+                if (npmPackage.name.startsWith('npm:@types/')) {
+                    const implementationNpmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1].substring(7));
+                    if (implementationNpmPackage) {
+                        touched.push(implementationNpmPackage.name);
+                    }
+                }
+                if ('packageName' in npmPackage.data) {
+                    if (globalPackages.has(npmPackage.data.packageName)) {
+                        return Object.keys(projectGraph.nodes);
+                    }
+                }
+            }
+        }
+        else if ((0, file_utils_1.isWholeFileChange)(c)) {
+            // Whole file was touched, so all npm packages are touched.
+            touched = npmPackages.map((pkg) => pkg.name);
+            break;
+        }
+    }
+    if (missingTouchedNpmPackages.length) {
+        logger_1.logger.warn(`The affected projects might have not been identified properly. The package(s) ${missingTouchedNpmPackages.join(', ')} were not found. Please open an issue in GitHub including the package.json file.`);
+    }
+    return touched;
+};
+exports.getTouchedNpmPackages = getTouchedNpmPackages;
+function getGlobalPackages(plugins) {
+    return (plugins ?? [])
+        .map((p) => (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(typeof p === 'string' ? p : p.plugin))
+        .concat('nx');
+}

package/src/plugins/js/project-graph/affected/touched-projects.d.ts

@@ -0,0 +1,2 @@
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedProjects: TouchedProjectLocator;

package/src/plugins/js/project-graph/affected/touched-projects.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjects = void 0;
+const lock_file_changes_1 = require("./lock-file-changes");
+const npm_packages_1 = require("./npm-packages");
+const tsconfig_json_changes_1 = require("./tsconfig-json-changes");
+const getTouchedProjects = (touchedFiles, nodes, nxJson, packageJson, graph) => {
+    const touchedProjects = new Set();
+    [
+        lock_file_changes_1.getTouchedProjectsFromLockFile,
+        npm_packages_1.getTouchedNpmPackages,
+        tsconfig_json_changes_1.getTouchedProjectsFromTsConfig,
+    ].forEach((fn) => {
+        fn(touchedFiles, nodes, nxJson, packageJson, graph).forEach((p) => touchedProjects.add(p));
+    });
+    return Array.from(touchedProjects);
+};
+exports.getTouchedProjects = getTouchedProjects;

package/src/plugins/js/project-graph/affected/tsconfig-json-changes.d.ts

@@ -0,0 +1,4 @@
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedProjectsFromTsConfig: TouchedProjectLocator<WholeFileChange | JsonChange>;

package/src/plugins/js/project-graph/affected/tsconfig-json-changes.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromTsConfig = void 0;
+const json_diff_1 = require("../../../../utils/json-diff");
+const typescript_1 = require("../../utils/typescript");
+const getTouchedProjectsFromTsConfig = (touchedFiles, _a, _b, _c, graph) => {
+    const rootTsConfig = (0, typescript_1.getRootTsConfigFileName)();
+    if (!rootTsConfig) {
+        return [];
+    }
+    const tsConfigJsonChanges = touchedFiles.find((change) => change.file === rootTsConfig);
+    if (!tsConfigJsonChanges) {
+        return [];
+    }
+    const changes = tsConfigJsonChanges.getChanges();
+    if (!allChangesArePathChanges(changes)) {
+        return Object.keys(graph.nodes);
+    }
+    const touched = [];
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        if (change.path.length !== 4) {
+            continue;
+        }
+        // If a path is deleted, everything is touched
+        if (change.type === json_diff_1.JsonDiffType.Deleted) {
+            return Object.keys(graph.nodes);
+        }
+        touched.push(...getProjectsAffectedByPaths(change, Object.values(graph.nodes)));
+    }
+    return touched;
+};
+exports.getTouchedProjectsFromTsConfig = getTouchedProjectsFromTsConfig;
+function allChangesArePathChanges(changes) {
+    return changes.every(isChangeToPathMappings);
+}
+/**
+ * Gets both previous project and current project of a particular change to tsconfig paths
+ */
+function getProjectsAffectedByPaths(change, nodes) {
+    const result = [];
+    const paths = [change.value.lhs, change.value.rhs];
+    paths.forEach((path) => {
+        nodes.forEach((project) => {
+            const normalizedPath = path && path.startsWith('./') ? path.substring(2) : path;
+            const r = project.data.root;
+            const root = r && r.endsWith('/') ? r.substring(0, r.length - 1) : r;
+            if ((normalizedPath && root && normalizedPath.startsWith(root)) ||
+                normalizedPath == root) {
+                result.push(project.name);
+            }
+        });
+    });
+    return result;
+}
+/**
+ * Change is possibly a change to path mappings
+ */
+function isChangeToPathMappings(change) {
+    return ((0, json_diff_1.isJsonChange)(change) &&
+        change.path[0] === 'compilerOptions' &&
+        (!change.path[1] || change.path[1] === 'paths'));
+}

package/src/plugins/js/project-graph/build-dependencies/build-dependencies.d.ts

@@ -0,0 +1,6 @@
+import { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+export declare function buildExplicitDependencies(jsPluginConfig: {
+    analyzeSourceFiles?: boolean;
+    analyzePackageJson?: boolean;
+}, ctx: CreateDependenciesContext): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/build-dependencies.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitDependencies = buildExplicitDependencies;
+const explicit_package_json_dependencies_1 = require("./explicit-package-json-dependencies");
+const explicit_project_dependencies_1 = require("./explicit-project-dependencies");
+const target_project_locator_1 = require("./target-project-locator");
+function buildExplicitDependencies(jsPluginConfig, ctx) {
+    if (totalNumberOfFilesToProcess(ctx) === 0)
+        return [];
+    let dependencies = [];
+    // TODO: TargetProjectLocator is a public API, so we can't change the shape of it
+    // We should eventually let it accept Record<string, ProjectConfiguration> s.t. we
+    // don't have to reshape the CreateDependenciesContext here.
+    const nodes = Object.fromEntries(Object.entries(ctx.projects).map(([key, config]) => [
+        key,
+        {
+            name: key,
+            type: null,
+            data: config,
+        },
+    ]));
+    const targetProjectLocator = new target_project_locator_1.TargetProjectLocator(nodes, ctx.externalNodes);
+    if (jsPluginConfig.analyzeSourceFiles === undefined ||
+        jsPluginConfig.analyzeSourceFiles === true) {
+        let tsExists = false;
+        try {
+            require.resolve('typescript');
+            tsExists = true;
+        }
+        catch { }
+        if (tsExists) {
+            dependencies = dependencies.concat((0, explicit_project_dependencies_1.buildExplicitTypeScriptDependencies)(ctx, targetProjectLocator));
+        }
+    }
+    if (jsPluginConfig.analyzePackageJson === undefined ||
+        jsPluginConfig.analyzePackageJson === true) {
+        dependencies = dependencies.concat((0, explicit_package_json_dependencies_1.buildExplicitPackageJsonDependencies)(ctx, targetProjectLocator));
+    }
+    return dependencies;
+}
+function totalNumberOfFilesToProcess(ctx) {
+    let totalNumOfFilesToProcess = 0;
+    Object.values(ctx.filesToProcess.projectFileMap).forEach((t) => (totalNumOfFilesToProcess += t.length));
+    return totalNumOfFilesToProcess;
+}

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts

@@ -0,0 +1,4 @@
+import { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+import { TargetProjectLocator } from './target-project-locator';
+export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitPackageJsonDependencies = buildExplicitPackageJsonDependencies;
+const node_path_1 = require("node:path");
+const project_graph_1 = require("../../../../config/project-graph");
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
+const json_1 = require("../../../../utils/json");
+const path_1 = require("../../../../utils/path");
+function buildExplicitPackageJsonDependencies(ctx, targetProjectLocator) {
+    const res = [];
+    let packageNameMap = undefined;
+    const nodes = Object.values(ctx.projects);
+    Object.keys(ctx.filesToProcess.projectFileMap).forEach((source) => {
+        Object.values(ctx.filesToProcess.projectFileMap[source]).forEach((f) => {
+            if (isPackageJsonAtProjectRoot(nodes, f.file)) {
+                // we only create the package name map once and only if a package.json file changes
+                packageNameMap = packageNameMap || createPackageNameMap(ctx.projects);
+                processPackageJson(source, f.file, ctx, targetProjectLocator, res, packageNameMap);
+            }
+        });
+    });
+    return res;
+}
+function createPackageNameMap(projects) {
+    const res = {};
+    for (let projectName of Object.keys(projects)) {
+        try {
+            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, node_path_1.join)(projects[projectName].root, 'package.json')));
+            res[packageJson.name ?? projectName] = projectName;
+        }
+        catch (e) { }
+    }
+    return res;
+}
+function isPackageJsonAtProjectRoot(nodes, fileName) {
+    return (fileName.endsWith('package.json') &&
+        nodes.find((projectNode) => (0, path_1.joinPathFragments)(projectNode.root, 'package.json') === fileName));
+}
+function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps, packageNameMap) {
+    try {
+        const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
+        for (const d of Object.keys(deps)) {
+            // package.json refers to another project in the monorepo
+            if (packageNameMap[d]) {
+                const dependency = {
+                    source: sourceProject,
+                    target: packageNameMap[d],
+                    sourceFile: fileName,
+                    type: project_graph_1.DependencyType.static,
+                };
+                (0, project_graph_builder_1.validateDependency)(dependency, ctx);
+                collectedDeps.push(dependency);
+                continue;
+            }
+            const externalNodeName = targetProjectLocator.findNpmProjectFromImport(d, fileName);
+            if (!externalNodeName) {
+                continue;
+            }
+            const dependency = {
+                source: sourceProject,
+                target: externalNodeName,
+                sourceFile: fileName,
+                type: project_graph_1.DependencyType.static,
+            };
+            (0, project_graph_builder_1.validateDependency)(dependency, ctx);
+            collectedDeps.push(dependency);
+        }
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+    }
+}
+function readDeps(packageJson) {
+    const deps = {};
+    /**
+     * We process dependencies in a rough order of increasing importance such that if a dependency is listed in multiple
+     * sections, the version listed under the "most important" one wins, with production dependencies being the most important.
+     */
+    const depType = [
+        'optionalDependencies',
+        'peerDependencies',
+        'devDependencies',
+        'dependencies',
+    ];
+    for (const type of depType) {
+        for (const [depName, depVersion] of Object.entries(packageJson[type] || {})) {
+            deps[depName] = depVersion;
+        }
+    }
+    return deps;
+}

package/src/plugins/js/project-graph/build-dependencies/explicit-project-dependencies.d.ts

@@ -0,0 +1,4 @@
+import { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+import { TargetProjectLocator } from './target-project-locator';
+export declare function buildExplicitTypeScriptDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];