@ohos-ports/nx 17.3.2-beta.0

package/src/plugins/js/lock-file/yarn-parser.js

@@ -0,0 +1,437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyYarnLockfile = exports.getYarnLockfileDependencies = exports.getYarnLockfileNodes = void 0;
+const package_json_1 = require("./utils/package-json");
+const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
+const semver_1 = require("semver");
+const project_graph_1 = require("../../../config/project-graph");
+const file_hasher_1 = require("../../../hasher/file-hasher");
+const object_sort_1 = require("../../../utils/object-sort");
+let currentLockFileHash;
+let cachedParsedLockFile;
+// we use key => node map to avoid duplicate work when parsing keys
+let keyMap = new Map();
+function parseLockFile(lockFileContent, lockFileHash) {
+    if (currentLockFileHash === lockFileHash) {
+        return cachedParsedLockFile;
+    }
+    const { parseSyml } = require('@yarnpkg/parsers');
+    keyMap.clear();
+    const result = parseSyml(lockFileContent);
+    cachedParsedLockFile = result;
+    currentLockFileHash = lockFileHash;
+    return result;
+}
+function getYarnLockfileNodes(lockFileContent, lockFileHash, packageJson) {
+    const { __metadata, ...dependencies } = parseLockFile(lockFileContent, lockFileHash);
+    const isBerry = !!__metadata;
+    // yarn classic splits keys when parsing so we need to stich them back together
+    const groupedDependencies = groupDependencies(dependencies, isBerry);
+    return getNodes(groupedDependencies, packageJson, keyMap, isBerry);
+}
+exports.getYarnLockfileNodes = getYarnLockfileNodes;
+function getYarnLockfileDependencies(lockFileContent, lockFileHash, ctx) {
+    const { __metadata, ...dependencies } = parseLockFile(lockFileContent, lockFileHash);
+    const isBerry = !!__metadata;
+    // yarn classic splits keys when parsing so we need to stich them back together
+    const groupedDependencies = groupDependencies(dependencies, isBerry);
+    return getDependencies(groupedDependencies, keyMap, ctx);
+}
+exports.getYarnLockfileDependencies = getYarnLockfileDependencies;
+function getPackageNameKeyPairs(keys) {
+    const result = new Map();
+    keys.split(', ').forEach((key) => {
+        const packageName = key.slice(0, key.indexOf('@', 1));
+        if (result.has(packageName)) {
+            result.get(packageName).add(key);
+        }
+        else {
+            result.set(packageName, new Set([key]));
+        }
+    });
+    return result;
+}
+function getNodes(dependencies, packageJson, keyMap, isBerry) {
+    const nodes = new Map();
+    const combinedDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies,
+        ...packageJson.optionalDependencies,
+    };
+    Object.entries(dependencies).forEach(([keys, snapshot]) => {
+        // ignore workspace projects & patches
+        if (snapshot.linkType === 'soft' || keys.includes('@patch:')) {
+            return;
+        }
+        const nameKeyPairs = getPackageNameKeyPairs(keys);
+        nameKeyPairs.forEach((keySet, packageName) => {
+            const keysArray = Array.from(keySet);
+            // use key relevant to the package name
+            const version = findVersion(packageName, keysArray[0], snapshot, isBerry);
+            // use keys linked to the extracted package name
+            keysArray.forEach((key) => {
+                // we don't need to keep duplicates, we can just track the keys
+                const existingNode = nodes.get(packageName)?.get(version);
+                if (existingNode) {
+                    keyMap.set(key, existingNode);
+                    return;
+                }
+                const node = {
+                    type: 'npm',
+                    name: version
+                        ? `npm:${packageName}@${version}`
+                        : `npm:${packageName}`,
+                    data: {
+                        version,
+                        packageName,
+                        hash: snapshot.integrity ||
+                            snapshot.checksum ||
+                            (0, file_hasher_1.hashArray)([packageName, version]),
+                    },
+                };
+                keyMap.set(key, node);
+                // use actual version so we can detect it later based on npm package's version
+                const mapKey = snapshot.version && version !== snapshot.version
+                    ? snapshot.version
+                    : version;
+                if (!nodes.has(packageName)) {
+                    nodes.set(packageName, new Map([[mapKey, node]]));
+                }
+                else {
+                    nodes.get(packageName).set(mapKey, node);
+                }
+            });
+        });
+    });
+    const externalNodes = {};
+    for (const [packageName, versionMap] of nodes.entries()) {
+        const hoistedNode = findHoistedNode(packageName, versionMap, combinedDeps);
+        if (hoistedNode) {
+            hoistedNode.name = `npm:${packageName}`;
+        }
+        versionMap.forEach((node) => {
+            externalNodes[node.name] = node;
+        });
+    }
+    return externalNodes;
+}
+function findHoistedNode(packageName, versionMap, combinedDeps) {
+    const hoistedVersion = getHoistedVersion(packageName);
+    if (hoistedVersion) {
+        return versionMap.get(hoistedVersion);
+    }
+    const rootVersionSpecifier = combinedDeps[packageName];
+    if (!rootVersionSpecifier) {
+        return;
+    }
+    const versions = Array.from(versionMap.keys()).sort((a, b) => (0, semver_1.gt)(a, b) ? -1 : 1);
+    // take the highest version found
+    if (rootVersionSpecifier === '*') {
+        return versionMap.get(versions[0]);
+    }
+    // take version that satisfies the root version specifier
+    let version = versions.find((v) => (0, semver_1.satisfies)(v, rootVersionSpecifier));
+    if (!version) {
+        // try to find alias version
+        version = versions.find((v) => versionMap.get(v).name === `npm:${packageName}@${rootVersionSpecifier}`);
+    }
+    if (!version) {
+        // try to find tarball package
+        version = versions.find((v) => versionMap.get(v).data.version !== v);
+    }
+    if (version) {
+        return versionMap.get(version);
+    }
+}
+function findVersion(packageName, key, snapshot, isBerry) {
+    const versionRange = key.slice(key.indexOf('@', 1) + 1);
+    // check for alias packages
+    const isAlias = isBerry
+        ? snapshot.resolution && !snapshot.resolution.startsWith(`${packageName}@`)
+        : versionRange.startsWith('npm:');
+    if (isAlias) {
+        return versionRange;
+    }
+    // check for berry tarball packages
+    if (isBerry &&
+        snapshot.resolution &&
+        // different registry would yield suffix following '::' which we don't need
+        snapshot.resolution.split('::')[0] !==
+            `${packageName}@npm:${snapshot.version}`) {
+        return snapshot.resolution.slice(packageName.length + 1);
+    }
+    if (!isBerry && isTarballPackage(versionRange, snapshot)) {
+        return snapshot.resolved;
+    }
+    // otherwise it's a standard version
+    return snapshot.version;
+}
+// check if snapshot represents tarball package
+function isTarballPackage(versionRange, snapshot) {
+    // if resolved is missing it's internal link
+    if (!snapshot.resolved) {
+        return false;
+    }
+    // tarballs have no integrity
+    if (snapshot.integrity) {
+        return false;
+    }
+    try {
+        new semver_1.Range(versionRange);
+        // range is a valid semver
+        return false;
+    }
+    catch {
+        // range is not a valid semver, it can be an npm tag or url part of a tarball
+        return snapshot.version && !snapshot.resolved.includes(snapshot.version);
+    }
+}
+function getHoistedVersion(packageName) {
+    const version = (0, package_json_1.getHoistedPackageVersion)(packageName);
+    if (version) {
+        return version;
+    }
+}
+function getDependencies(dependencies, keyMap, ctx) {
+    const projectGraphDependencies = [];
+    Object.keys(dependencies).forEach((keys) => {
+        const snapshot = dependencies[keys];
+        keys.split(', ').forEach((key) => {
+            if (keyMap.has(key)) {
+                const node = keyMap.get(key);
+                [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
+                    if (section) {
+                        Object.entries(section).forEach(([name, versionRange]) => {
+                            const target = keyMap.get(`${name}@npm:${versionRange}`) ||
+                                keyMap.get(`${name}@${versionRange}`);
+                            if (target) {
+                                const dep = {
+                                    source: node.name,
+                                    target: target.name,
+                                    type: project_graph_1.DependencyType.static,
+                                };
+                                (0, project_graph_builder_1.validateDependency)(dep, ctx);
+                                projectGraphDependencies.push(dep);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    });
+    return projectGraphDependencies;
+}
+function stringifyYarnLockfile(graph, rootLockFileContent, packageJson) {
+    const { parseSyml, stringifySyml } = require('@yarnpkg/parsers');
+    const { __metadata, ...dependencies } = parseSyml(rootLockFileContent);
+    const isBerry = !!__metadata;
+    const snapshots = mapSnapshots(dependencies, graph.externalNodes, packageJson, isBerry);
+    if (isBerry) {
+        // add root workspace package
+        const workspacePackage = generateRootWorkspacePackage(packageJson);
+        snapshots[workspacePackage.resolution] = workspacePackage;
+        return (BERRY_LOCK_FILE_DISCLAIMER +
+            stringifySyml({
+                __metadata,
+                ...(0, object_sort_1.sortObjectByKeys)(snapshots),
+            }));
+    }
+    else {
+        const { stringify } = require('@yarnpkg/lockfile');
+        return stringify((0, object_sort_1.sortObjectByKeys)(snapshots));
+    }
+}
+exports.stringifyYarnLockfile = stringifyYarnLockfile;
+function groupDependencies(dependencies, isBerry) {
+    if (isBerry) {
+        return dependencies;
+    }
+    let groupedDependencies;
+    const resolutionMap = new Map();
+    const snapshotMap = new Map();
+    Object.entries(dependencies).forEach(([key, snapshot]) => {
+        const resolutionKey = `${snapshot.resolved}${snapshot.integrity}`;
+        if (resolutionMap.has(resolutionKey)) {
+            const existingSnapshot = resolutionMap.get(resolutionKey);
+            snapshotMap.get(existingSnapshot).add(key);
+        }
+        else {
+            resolutionMap.set(resolutionKey, snapshot);
+            snapshotMap.set(snapshot, new Set([key]));
+        }
+    });
+    groupedDependencies = {};
+    snapshotMap.forEach((keys, snapshot) => {
+        groupedDependencies[Array.from(keys).join(', ')] = snapshot;
+    });
+    return groupedDependencies;
+}
+function addPackageVersion(packageName, version, collection, isBerry) {
+    if (!collection.has(packageName)) {
+        collection.set(packageName, new Set());
+    }
+    collection.get(packageName).add(`${packageName}@${version}`);
+    if (isBerry && !version.startsWith('npm:')) {
+        collection.get(packageName).add(`${packageName}@npm:${version}`);
+    }
+}
+function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
+    // map snapshot to set of keys (e.g. `eslint@^7.0.0, eslint@npm:^7.0.0`)
+    const snapshotMap = new Map();
+    // track all existing dependencies's keys
+    const existingKeys = new Map();
+    const combinedDependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.optionalDependencies,
+        ...packageJson.peerDependencies,
+    };
+    // yarn classic splits keys when parsing so we need to stich them back together
+    const groupedDependencies = groupDependencies(dependencies, isBerry);
+    // collect snapshots and their matching keys
+    Object.values(nodes).forEach((node) => {
+        const foundOriginalKeys = findOriginalKeys(groupedDependencies, node);
+        if (!foundOriginalKeys) {
+            throw new Error(`Original key(s) not found for "${node.data.packageName}@${node.data.version}" while pruning yarn.lock.`);
+        }
+        const [matchedKeys, snapshot] = foundOriginalKeys;
+        snapshotMap.set(snapshot, new Set(matchedKeys));
+        // separately save keys that still exist
+        [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
+            Object.entries(section || {}).forEach(([name, versionSpec]) => addPackageVersion(name, versionSpec, existingKeys, isBerry));
+        });
+        // add package.json requested version to keys
+        const requestedVersion = getPackageJsonVersion(combinedDependencies, node);
+        if (requestedVersion) {
+            addPackageVersion(node.data.packageName, requestedVersion, existingKeys, isBerry);
+            const requestedKey = isBerry
+                ? reverseMapBerryKey(node, requestedVersion, snapshot)
+                : `${node.data.packageName}@${requestedVersion}`;
+            if (!snapshotMap.get(snapshot).has(requestedKey)) {
+                snapshotMap.get(snapshot).add(requestedKey);
+            }
+        }
+        if (isBerry) {
+            // look for patched versions
+            const patch = findPatchedKeys(groupedDependencies, node);
+            if (patch) {
+                const [matchedKeys, snapshot] = patch;
+                snapshotMap.set(snapshot, new Set(matchedKeys));
+            }
+        }
+    });
+    // remove keys that match version ranges that have been pruned away
+    snapshotMap.forEach((snapshotValue, snapshotKey) => {
+        for (const key of snapshotValue.values()) {
+            const packageName = key.slice(0, key.indexOf('@', 1));
+            let normalizedKey = key;
+            if (isBerry && key.includes('@patch:') && key.includes('#')) {
+                normalizedKey = key
+                    .slice(0, key.indexOf('#'))
+                    .replace(`@patch:${packageName}@`, '@npm:');
+            }
+            if (!existingKeys.get(packageName) ||
+                !existingKeys.get(packageName).has(normalizedKey)) {
+                snapshotValue.delete(key);
+            }
+        }
+    });
+    // join mapped snapshots to lock json file
+    const result = {};
+    snapshotMap.forEach((keysSet, snapshot) => {
+        if (isBerry) {
+            result[Array.from(keysSet).sort().join(', ')] = snapshot;
+        }
+        else {
+            for (const key of keysSet.values()) {
+                result[key] = snapshot;
+            }
+        }
+    });
+    return result;
+}
+function reverseMapBerryKey(node, version, snapshot) {
+    // alias packages already have version
+    if (version.startsWith('npm:')) {
+        `${node.data.packageName}@${version}`;
+    }
+    // check for berry tarball packages
+    if (snapshot.resolution &&
+        snapshot.resolution === `${node.data.packageName}@${version}`) {
+        return snapshot.resolution;
+    }
+    return `${node.data.packageName}@npm:${version}`;
+}
+function getPackageJsonVersion(combinedDependencies, node) {
+    const { packageName, version } = node.data;
+    if (combinedDependencies[packageName]) {
+        if (combinedDependencies[packageName] === version ||
+            (0, semver_1.satisfies)(version, combinedDependencies[packageName])) {
+            return combinedDependencies[packageName];
+        }
+    }
+}
+function findOriginalKeys(dependencies, node) {
+    for (const keyExpr of Object.keys(dependencies)) {
+        const snapshot = dependencies[keyExpr];
+        const keys = keyExpr.split(', ');
+        if (!keys.some((k) => k.startsWith(`${node.data.packageName}@`))) {
+            continue;
+        }
+        // standard package
+        if (snapshot.version === node.data.version) {
+            return [keys, snapshot];
+        }
+        // berry alias package
+        if (snapshot.resolution &&
+            `npm:${snapshot.resolution}` === node.data.version) {
+            return [keys, snapshot];
+        }
+        // classic alias
+        if (node.data.version.startsWith('npm:') &&
+            keys.some((k) => k === `${node.data.packageName}@${node.data.version}`)) {
+            return [keys, snapshot];
+        }
+        // tarball package
+        if (snapshot.resolved === node.data.version ||
+            snapshot.resolution === `${node.data.packageName}@${node.data.version}`) {
+            return [keys, snapshot];
+        }
+    }
+}
+function findPatchedKeys(dependencies, node) {
+    for (const keyExpr of Object.keys(dependencies)) {
+        const snapshot = dependencies[keyExpr];
+        const keys = keyExpr.split(', ');
+        if (!keys[0].startsWith(`${node.data.packageName}@patch:`)) {
+            continue;
+        }
+        // local patches are currently not supported
+        if (keys[0].includes('.yarn/patches')) {
+            continue;
+        }
+        if (snapshot.version === node.data.version) {
+            return [keys, snapshot];
+        }
+    }
+}
+const BERRY_LOCK_FILE_DISCLAIMER = `# This file is generated by running "yarn install" inside your project.\n# Manual changes might be lost - proceed with caution!\n\n`;
+function generateRootWorkspacePackage(packageJson) {
+    return {
+        version: '0.0.0-use.local',
+        resolution: `${packageJson.name}@workspace:.`,
+        ...(packageJson.dependencies && { dependencies: packageJson.dependencies }),
+        ...(packageJson.peerDependencies && {
+            peerDependencies: packageJson.peerDependencies,
+        }),
+        ...(packageJson.devDependencies && {
+            devDependencies: packageJson.devDependencies,
+        }),
+        ...(packageJson.optionalDependencies && {
+            optionalDependencies: packageJson.optionalDependencies,
+        }),
+        languageName: 'unknown',
+        linkType: 'soft',
+    };
+}

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

@@ -0,0 +1,27 @@
+import { ProjectFileMap, ProjectGraph, ProjectGraphProjectNode } from '../../../config/project-graph';
+import { PackageJson } from '../../../utils/package-json';
+interface NpmDeps {
+    readonly dependencies: Record<string, string>;
+    readonly peerDependencies: Record<string, string>;
+    readonly peerDependenciesMeta: Record<string, {
+        optional: boolean;
+    }>;
+}
+/**
+ * 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
+ */
+export declare function createPackageJson(projectName: string, graph: ProjectGraph, options?: {
+    target?: string;
+    root?: string;
+    isProduction?: boolean;
+    helperDependencies?: string[];
+}, fileMap?: ProjectFileMap): PackageJson;
+export declare function findProjectsNpmDependencies(projectNode: ProjectGraphProjectNode, graph: ProjectGraph, target: string, rootPackageJson: PackageJson, options: {
+    helperDependencies?: string[];
+    ignoredDependencies?: string[];
+    isProduction?: boolean;
+}, fileMap?: ProjectFileMap): NpmDeps;
+export {};

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectsNpmDependencies = exports.createPackageJson = void 0;
+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");
+/**
+ * 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)(`${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;
+            }
+        }
+        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);
+    return packageJson;
+}
+exports.createPackageJson = createPackageJson;
+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;
+}
+exports.findProjectsNpmDependencies = findProjectsNpmDependencies;
+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>;