nx 20.8.4 → 22.7.7

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

@@ -1,466 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPnpmLockfileNodes = getPnpmLockfileNodes;
-exports.getPnpmLockfileDependencies = getPnpmLockfileDependencies;
-exports.stringifyPnpmLockfile = stringifyPnpmLockfile;
-const pnpm_normalizer_1 = require("./utils/pnpm-normalizer");
-const package_json_1 = require("./utils/package-json");
-const object_sort_1 = require("../../../utils/object-sort");
-const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
-const project_graph_1 = require("../../../config/project-graph");
-const file_hasher_1 = require("../../../hasher/file-hasher");
-// we use key => node map to avoid duplicate work when parsing keys
-let keyMap = new Map();
-let currentLockFileHash;
-let parsedLockFile;
-function parsePnpmLockFile(lockFileContent, lockFileHash) {
-    if (lockFileHash === currentLockFileHash) {
-        return parsedLockFile;
-    }
-    keyMap.clear();
-    const results = (0, pnpm_normalizer_1.parseAndNormalizePnpmLockfile)(lockFileContent);
-    parsedLockFile = results;
-    currentLockFileHash = lockFileHash;
-    return results;
-}
-function getPnpmLockfileNodes(lockFileContent, lockFileHash) {
-    const data = parsePnpmLockFile(lockFileContent, lockFileHash);
-    if (+data.lockfileVersion.toString() >= 10) {
-        console.warn('Nx was tested only with pnpm lockfile version 5-9. If you encounter any issues, please report them and downgrade to older version of pnpm.');
-    }
-    const isV5 = (0, pnpm_normalizer_1.isV5Syntax)(data);
-    return getNodes(data, keyMap, isV5);
-}
-function getPnpmLockfileDependencies(lockFileContent, lockFileHash, ctx) {
-    const data = parsePnpmLockFile(lockFileContent, lockFileHash);
-    if (+data.lockfileVersion.toString() >= 10) {
-        console.warn('Nx was tested only with pnpm lockfile version 5-9. If you encounter any issues, please report them and downgrade to older version of pnpm.');
-    }
-    const isV5 = (0, pnpm_normalizer_1.isV5Syntax)(data);
-    return getDependencies(data, keyMap, isV5, ctx);
-}
-function matchPropValue(record, key, originalPackageName) {
-    if (!record) {
-        return undefined;
-    }
-    const index = Object.values(record).findIndex((version) => version === key);
-    if (index > -1) {
-        return Object.keys(record)[index];
-    }
-    // check if non-aliased name is found
-    if (record[originalPackageName] &&
-        key.startsWith(`/${originalPackageName}/${record[originalPackageName]}`)) {
-        return originalPackageName;
-    }
-}
-function matchedDependencyName(importer, key, originalPackageName) {
-    return (matchPropValue(importer.dependencies, key, originalPackageName) ||
-        matchPropValue(importer.optionalDependencies, key, originalPackageName) ||
-        matchPropValue(importer.peerDependencies, key, originalPackageName));
-}
-function createHashFromSnapshot(snapshot) {
-    return (snapshot.resolution?.['integrity'] ||
-        (snapshot.resolution?.['tarball']
-            ? (0, file_hasher_1.hashArray)([snapshot.resolution['tarball']])
-            : undefined));
-}
-function isAliasVersion(depVersion) {
-    return depVersion.startsWith('/') || depVersion.includes('@');
-}
-function getNodes(data, keyMap, isV5) {
-    const nodes = new Map();
-    const maybeAliasedPackageVersions = new Map(); // <version, alias>
-    if (data.importers['.'].optionalDependencies) {
-        for (const [depName, depVersion] of Object.entries(data.importers['.'].optionalDependencies)) {
-            if (isAliasVersion(depVersion)) {
-                maybeAliasedPackageVersions.set(depVersion, depName);
-            }
-        }
-    }
-    if (data.importers['.'].devDependencies) {
-        for (const [depName, depVersion] of Object.entries(data.importers['.'].devDependencies)) {
-            if (isAliasVersion(depVersion)) {
-                maybeAliasedPackageVersions.set(depVersion, depName);
-            }
-        }
-    }
-    if (data.importers['.'].dependencies) {
-        for (const [depName, depVersion] of Object.entries(data.importers['.'].dependencies)) {
-            if (isAliasVersion(depVersion)) {
-                maybeAliasedPackageVersions.set(depVersion, depName);
-            }
-        }
-    }
-    const packageNames = new Set();
-    let packageNameObj;
-    for (const [key, snapshot] of Object.entries(data.packages)) {
-        const originalPackageName = extractNameFromKey(key, isV5);
-        if (!originalPackageName) {
-            continue;
-        }
-        const hash = createHashFromSnapshot(snapshot);
-        // snapshot already has a name
-        if (snapshot.name) {
-            packageNameObj = {
-                key,
-                packageName: snapshot.name,
-                hash,
-            };
-        }
-        const rootDependencyName = matchedDependencyName(data.importers['.'], key, originalPackageName) ||
-            matchedDependencyName(data.importers['.'], `/${key}`, originalPackageName) ||
-            // only root importers have devDependencies
-            matchPropValue(data.importers['.'].devDependencies, key, originalPackageName) ||
-            matchPropValue(data.importers['.'].devDependencies, `/${key}`, originalPackageName);
-        if (rootDependencyName) {
-            packageNameObj = {
-                key,
-                packageName: rootDependencyName,
-                hash: createHashFromSnapshot(snapshot),
-            };
-        }
-        if (!snapshot.name && !rootDependencyName) {
-            packageNameObj = {
-                key,
-                packageName: originalPackageName,
-                hash: createHashFromSnapshot(snapshot),
-            };
-        }
-        if (snapshot.peerDependencies) {
-            for (const [depName, depVersion] of Object.entries(snapshot.peerDependencies)) {
-                if (isAliasVersion(depVersion)) {
-                    maybeAliasedPackageVersions.set(depVersion, depName);
-                }
-            }
-        }
-        if (snapshot.optionalDependencies) {
-            for (const [depName, depVersion] of Object.entries(snapshot.optionalDependencies)) {
-                if (isAliasVersion(depVersion)) {
-                    maybeAliasedPackageVersions.set(depVersion, depName);
-                }
-            }
-        }
-        if (snapshot.dependencies) {
-            for (const [depName, depVersion] of Object.entries(snapshot.dependencies)) {
-                if (isAliasVersion(depVersion)) {
-                    maybeAliasedPackageVersions.set(depVersion, depName);
-                }
-            }
-        }
-        const aliasedDep = maybeAliasedPackageVersions.get(`/${key}`);
-        if (aliasedDep) {
-            packageNameObj = {
-                key,
-                packageName: aliasedDep,
-                hash,
-                alias: true,
-            };
-        }
-        packageNames.add(packageNameObj);
-        const localAlias = maybeAliasedPackageVersions.get(key);
-        if (localAlias) {
-            packageNameObj = {
-                key,
-                packageName: localAlias,
-                hash,
-                alias: true,
-            };
-            packageNames.add(packageNameObj);
-        }
-    }
-    for (const { key, packageName, hash, alias } of packageNames) {
-        const rawVersion = findVersion(key, packageName, isV5, alias);
-        if (!rawVersion) {
-            continue;
-        }
-        const version = parseBaseVersion(rawVersion, isV5);
-        if (!version) {
-            continue;
-        }
-        if (!nodes.has(packageName)) {
-            nodes.set(packageName, new Map());
-        }
-        if (!nodes.get(packageName).has(version)) {
-            const node = {
-                type: 'npm',
-                name: version && !version.startsWith('npm:')
-                    ? `npm:${packageName}@${version}`
-                    : `npm:${packageName}`,
-                data: {
-                    version,
-                    packageName,
-                    hash: hash ?? (0, file_hasher_1.hashArray)([packageName, version]),
-                },
-            };
-            nodes.get(packageName).set(version, node);
-            if (!keyMap.has(key)) {
-                keyMap.set(key, new Set([node]));
-            }
-            else {
-                keyMap.get(key).add(node);
-            }
-        }
-        else {
-            const node = nodes.get(packageName).get(version);
-            if (!keyMap.has(key)) {
-                keyMap.set(key, new Set([node]));
-            }
-            else {
-                keyMap.get(key).add(node);
-            }
-        }
-    }
-    const hoistedDeps = (0, pnpm_normalizer_1.loadPnpmHoistedDepsDefinition)();
-    const results = {};
-    for (const [packageName, versionMap] of nodes.entries()) {
-        let hoistedNode;
-        if (versionMap.size === 1) {
-            hoistedNode = versionMap.values().next().value;
-        }
-        else {
-            const hoistedVersion = getHoistedVersion(hoistedDeps, packageName, isV5);
-            hoistedNode = versionMap.get(hoistedVersion);
-        }
-        if (hoistedNode) {
-            hoistedNode.name = `npm:${packageName}`;
-        }
-        versionMap.forEach((node) => {
-            results[node.name] = node;
-        });
-    }
-    return results;
-}
-function getHoistedVersion(hoistedDependencies, packageName, isV5) {
-    let version = (0, package_json_1.getHoistedPackageVersion)(packageName);
-    if (!version) {
-        const key = Object.keys(hoistedDependencies).find((k) => k.startsWith(`/${packageName}/`));
-        if (key) {
-            version = parseBaseVersion(getVersion(key.slice(1), packageName), isV5);
-        }
-        else {
-            // pnpm might not hoist every package
-            // similarly those packages will not be available to be used via import
-            return;
-        }
-    }
-    return version;
-}
-function getDependencies(data, keyMap, isV5, ctx) {
-    const results = [];
-    Object.entries(data.packages).forEach(([key, snapshot]) => {
-        const nodes = keyMap.get(key);
-        nodes.forEach((node) => {
-            [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
-                if (section) {
-                    Object.entries(section).forEach(([name, versionRange]) => {
-                        const version = parseBaseVersion(findVersion(versionRange, name, isV5), isV5);
-                        const target = ctx.externalNodes[`npm:${name}@${version}`] ||
-                            ctx.externalNodes[`npm:${name}`];
-                        if (target) {
-                            const dep = {
-                                source: node.name,
-                                target: target.name,
-                                type: project_graph_1.DependencyType.static,
-                            };
-                            (0, project_graph_builder_1.validateDependency)(dep, ctx);
-                            results.push(dep);
-                        }
-                    });
-                }
-            });
-        });
-    });
-    return results;
-}
-function parseBaseVersion(rawVersion, isV5) {
-    return isV5 ? rawVersion.split('_')[0] : rawVersion.split('(')[0];
-}
-function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson) {
-    const data = (0, pnpm_normalizer_1.parseAndNormalizePnpmLockfile)(rootLockFileContent);
-    const { lockfileVersion, packages } = data;
-    const rootSnapshot = mapRootSnapshot(packageJson, packages, graph.externalNodes, +lockfileVersion);
-    const snapshots = mapSnapshots(data.packages, graph.externalNodes, +lockfileVersion);
-    const output = {
-        ...data,
-        lockfileVersion,
-        importers: {
-            '.': rootSnapshot,
-        },
-        packages: (0, object_sort_1.sortObjectByKeys)(snapshots),
-    };
-    return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
-}
-function mapSnapshots(packages, nodes, lockfileVersion) {
-    const result = {};
-    Object.values(nodes).forEach((node) => {
-        const matchedKeys = findOriginalKeys(packages, node, lockfileVersion, {
-            returnFullKey: true,
-        });
-        // the package manager doesn't check for types of dependencies
-        // so we can safely set all to prod
-        matchedKeys.forEach(([key, snapshot]) => {
-            if (lockfileVersion >= 9) {
-                delete snapshot['dev'];
-                result[key] = snapshot;
-            }
-            else {
-                snapshot['dev'] = false; // all dependencies are prod
-                remapDependencies(snapshot);
-                if (snapshot.resolution?.['tarball']) {
-                    // tarballs are not prefixed with /
-                    result[key] = snapshot;
-                }
-                else {
-                    result[`/${key}`] = snapshot;
-                }
-            }
-        });
-    });
-    return result;
-}
-function remapDependencies(snapshot) {
-    [
-        'dependencies',
-        'optionalDependencies',
-        'devDependencies',
-        'peerDependencies',
-    ].forEach((depType) => {
-        if (snapshot[depType]) {
-            for (const [packageName, version] of Object.entries(snapshot[depType])) {
-                if (version.match(/^[a-zA-Z]+.*/)) {
-                    // remap packageName@version to packageName/version
-                    snapshot[depType][packageName] = `/${version.replace(/([a-zA-Z].+)@/, '$1/')}`;
-                }
-            }
-        }
-    });
-}
-function findOriginalKeys(packages, { data: { packageName, version } }, lockfileVersion, { returnFullKey } = {}) {
-    const matchedKeys = [];
-    for (const key of Object.keys(packages)) {
-        const snapshot = packages[key];
-        // tarball package
-        if (key.startsWith(`${packageName}@${version}`) &&
-            snapshot.resolution?.['tarball']) {
-            matchedKeys.push([getVersion(key, packageName), snapshot]);
-        }
-        // standard package
-        if (lockfileVersion < 6 && key.startsWith(`${packageName}/${version}`)) {
-            matchedKeys.push([
-                returnFullKey ? key : getVersion(key, packageName),
-                snapshot,
-            ]);
-        }
-        if (lockfileVersion >= 6 &&
-            lockfileVersion < 9 &&
-            key.startsWith(`${packageName}@${version}`)) {
-            matchedKeys.push([
-                // we need to replace the @ with / for v5-7 syntax because the dpParse function expects old format
-                returnFullKey
-                    ? key.replace(`${packageName}@${version}`, `${packageName}/${version}`)
-                    : getVersion(key, packageName),
-                snapshot,
-            ]);
-        }
-        if (lockfileVersion >= 9 && key.startsWith(`${packageName}@${version}`)) {
-            matchedKeys.push([
-                returnFullKey ? key : getVersion(key, packageName),
-                snapshot,
-            ]);
-        }
-        // alias package
-        if (versionIsAlias(key, version, lockfileVersion)) {
-            if (lockfileVersion >= 9) {
-                // no postprocessing needed for v9
-                matchedKeys.push([key, snapshot]);
-            }
-            else {
-                // for root specifiers we need to ensure alias is prefixed with /
-                const prefixedKey = returnFullKey ? key : `/${key}`;
-                const mappedKey = prefixedKey.replace(/(\/?..+)@/, '$1/');
-                matchedKeys.push([mappedKey, snapshot]);
-            }
-        }
-    }
-    return matchedKeys;
-}
-// check if version has a form of npm:packageName@version and
-// key starts with /packageName/version
-function versionIsAlias(key, versionExpr, lockfileVersion) {
-    const PREFIX = 'npm:';
-    if (!versionExpr.startsWith(PREFIX))
-        return false;
-    const indexOfVersionSeparator = versionExpr.indexOf('@', PREFIX.length + 1);
-    const packageName = versionExpr.slice(PREFIX.length, indexOfVersionSeparator);
-    const version = versionExpr.slice(indexOfVersionSeparator + 1);
-    return lockfileVersion < 6
-        ? key.startsWith(`${packageName}/${version}`)
-        : key.startsWith(`${packageName}@${version}`);
-}
-function mapRootSnapshot(packageJson, packages, nodes, lockfileVersion) {
-    const snapshot = { specifiers: {} };
-    [
-        'dependencies',
-        'optionalDependencies',
-        'devDependencies',
-        'peerDependencies',
-    ].forEach((depType) => {
-        if (packageJson[depType]) {
-            Object.keys(packageJson[depType]).forEach((packageName) => {
-                const version = packageJson[depType][packageName];
-                const node = nodes[`npm:${packageName}@${version}`] || nodes[`npm:${packageName}`];
-                snapshot.specifiers[packageName] = version;
-                // peer dependencies are mapped to dependencies
-                let section = depType === 'peerDependencies' ? 'dependencies' : depType;
-                snapshot[section] = snapshot[section] || {};
-                snapshot[section][packageName] = findOriginalKeys(packages, node, lockfileVersion)[0][0];
-            });
-        }
-    });
-    Object.keys(snapshot).forEach((key) => {
-        snapshot[key] = (0, object_sort_1.sortObjectByKeys)(snapshot[key]);
-    });
-    return snapshot;
-}
-function findVersion(key, packageName, isV5, alias) {
-    if (isV5 && key.startsWith(`${packageName}/`)) {
-        return getVersion(key, packageName);
-    }
-    // this matches v6 syntax and tarball packages
-    if (key.startsWith(`${packageName}@`)) {
-        return getVersion(key, packageName);
-    }
-    if (alias) {
-        const aliasName = isV5
-            ? key.slice(0, key.lastIndexOf('/'))
-            : key.slice(0, key.indexOf('@', 2)); // we use 2 to ensure we don't catch the first @
-        const version = getVersion(key, aliasName);
-        return `npm:${aliasName}@${version}`;
-    }
-    // for tarball package the entire key is the version spec
-    return key;
-}
-function getVersion(key, packageName) {
-    return key.slice(packageName.length + 1);
-}
-function extractNameFromKey(key, isV5) {
-    // if package name contains org e.g. "@babel/runtime@7.12.5"
-    if (key.startsWith('@')) {
-        if (isV5) {
-            const startFrom = key.indexOf('/');
-            return key.slice(0, key.indexOf('/', startFrom + 1));
-        }
-        else {
-            // find the position of the '@'
-            return key.slice(0, key.indexOf('@', 1));
-        }
-    }
-    if (isV5) {
-        // if package has just a name e.g. "react/7.12.5..."
-        return key.slice(0, key.indexOf('/', 1));
-    }
-    else {
-        // if package has just a name e.g. "react@7.12.5..."
-        return key.slice(0, key.indexOf('@', 1));
-    }
-}

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

@@ -1,7 +0,0 @@
-import { ProjectGraph } from '../../../config/project-graph';
-import { PackageJson } from '../../../utils/package-json';
-/**
- * Prune project graph's external nodes and their dependencies
- * based on the pruned package.json
- */
-export declare function pruneProjectGraph(graph: ProjectGraph, prunedPackageJson: PackageJson): ProjectGraph;

package/src/plugins/js/lock-file/project-graph-pruning.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pruneProjectGraph = pruneProjectGraph;
-const semver_1 = require("semver");
-const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
-const operators_1 = require("../../../project-graph/operators");
-/**
- * Prune project graph's external nodes and their dependencies
- * based on the pruned package.json
- */
-function pruneProjectGraph(graph, prunedPackageJson) {
-    const builder = new project_graph_builder_1.ProjectGraphBuilder();
-    const combinedDependencies = normalizeDependencies(prunedPackageJson, graph);
-    addNodesAndDependencies(graph, combinedDependencies, builder);
-    // for NPM (as well as the graph consistency)
-    // we need to distinguish between hoisted and non-hoisted dependencies
-    rehoistNodes(graph, combinedDependencies, builder);
-    return builder.getUpdatedProjectGraph();
-}
-// ensure that dependency ranges from package.json (e.g. ^1.0.0)
-// are replaced with the actual version based on the available nodes (e.g. 1.0.1)
-function normalizeDependencies(packageJson, graph) {
-    const { dependencies, devDependencies, optionalDependencies, peerDependencies, } = packageJson;
-    const combinedDependencies = {
-        ...dependencies,
-        ...devDependencies,
-        ...optionalDependencies,
-        ...peerDependencies,
-    };
-    Object.entries(combinedDependencies).forEach(([packageName, versionRange]) => {
-        if (graph.externalNodes[`npm:${packageName}@${versionRange}`]) {
-            return;
-        }
-        if (graph.externalNodes[`npm:${packageName}`] &&
-            graph.externalNodes[`npm:${packageName}`].data.version === versionRange) {
-            return;
-        }
-        // otherwise we need to find the correct version
-        const node = findNodeMatchingVersion(graph, packageName, versionRange);
-        if (node) {
-            combinedDependencies[packageName] = node.data.version;
-        }
-        else {
-            throw new Error(`Pruned lock file creation failed. The following package was not found in the root lock file: ${packageName}@${versionRange}`);
-        }
-    });
-    return combinedDependencies;
-}
-function findNodeMatchingVersion(graph, packageName, versionExpr) {
-    if (versionExpr === '*') {
-        return graph.externalNodes[`npm:${packageName}`];
-    }
-    const nodes = Object.values(graph.externalNodes)
-        .filter((n) => n.data.packageName === packageName)
-        .sort((a, b) => ((0, semver_1.gte)(b.data.version, a.data.version) ? 1 : -1));
-    if (versionExpr === 'latest') {
-        return nodes.sort((a, b) => +(0, semver_1.gte)(b.data.version, a.data.version))[0];
-    }
-    if (graph.externalNodes[`npm:${packageName}`] &&
-        (0, semver_1.satisfies)(graph.externalNodes[`npm:${packageName}`].data.version, versionExpr)) {
-        return graph.externalNodes[`npm:${packageName}`];
-    }
-    return nodes.find((n) => (0, semver_1.satisfies)(n.data.version, versionExpr));
-}
-function addNodesAndDependencies(graph, packageJsonDeps, builder) {
-    Object.entries(packageJsonDeps).forEach(([name, version]) => {
-        const node = graph.externalNodes[`npm:${name}@${version}`] ||
-            graph.externalNodes[`npm:${name}`];
-        traverseNode(graph, builder, node);
-    });
-}
-function traverseNode(graph, builder, node) {
-    if (builder.graph.externalNodes[node.name]) {
-        return;
-    }
-    builder.addExternalNode(node);
-    graph.dependencies[node.name]?.forEach((dep) => {
-        const depNode = graph.externalNodes[dep.target];
-        traverseNode(graph, builder, depNode);
-        builder.addStaticDependency(node.name, dep.target);
-    });
-}
-function rehoistNodes(graph, packageJsonDeps, builder) {
-    const packagesToRehoist = new Map();
-    // find all packages that need to be rehoisted
-    Object.values(graph.externalNodes).forEach((node) => {
-        if (node.name === `npm:${node.data.packageName}` &&
-            !builder.graph.externalNodes[node.name]) {
-            const nestedNodes = Object.values(builder.graph.externalNodes).filter((n) => n.data.packageName === node.data.packageName);
-            if (nestedNodes.length > 0) {
-                packagesToRehoist.set(node.data.packageName, nestedNodes);
-            }
-        }
-    });
-    // invert dependencies for easier traversal back
-    const invertedGraph = (0, operators_1.reverse)(builder.graph);
-    const invBuilder = new project_graph_builder_1.ProjectGraphBuilder(invertedGraph, {});
-    // find new hoisted version
-    packagesToRehoist.forEach((nestedNodes) => {
-        if (nestedNodes.length === 1) {
-            switchNodeToHoisted(nestedNodes[0], builder, invBuilder);
-        }
-        else {
-            let minDistance = Infinity;
-            let closest;
-            nestedNodes.forEach((node) => {
-                const distance = pathLengthToIncoming(node, packageJsonDeps, builder, invertedGraph);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    closest = node;
-                }
-            });
-            switchNodeToHoisted(closest, builder, invBuilder);
-        }
-    });
-}
-function switchNodeToHoisted(node, builder, invBuilder) {
-    // make a copy of current name, all the dependencies and dependents
-    const previousName = node.name;
-    const targets = (builder.graph.dependencies[node.name] || []).map((d) => d.target);
-    const sources = Object.keys(builder.graph.dependencies).filter((name) => builder.graph.dependencies[name].some((d) => d.target === previousName));
-    builder.removeNode(node.name);
-    invBuilder.removeNode(node.name);
-    // modify the node and re-add it
-    node.name = `npm:${node.data.packageName}`;
-    builder.addExternalNode(node);
-    invBuilder.addExternalNode(node);
-    targets.forEach((target) => {
-        builder.addStaticDependency(node.name, target);
-        invBuilder.addStaticDependency(target, node.name);
-    });
-    sources.forEach((source) => {
-        builder.addStaticDependency(source, node.name);
-        invBuilder.addStaticDependency(node.name, source);
-    });
-}
-// BFS to find the shortest path to a dependency specified in package.json
-// package version with the shortest path is the one that should be hoisted
-function pathLengthToIncoming(node, packageJsonDeps, builder, invertedGraph) {
-    const visited = new Set([node.name]);
-    const queue = [[node, 0]];
-    while (queue.length > 0) {
-        const [current, distance] = queue.shift();
-        if (packageJsonDeps[current.data.packageName] === current.data.version) {
-            return distance;
-        }
-        for (let { target } of invertedGraph.dependencies[current.name] || []) {
-            if (!visited.has(target)) {
-                visited.add(target);
-                queue.push([builder.graph.externalNodes[target], distance + 1]);
-            }
-        }
-    }
-}

package/src/plugins/js/lock-file/utils/package-json.d.ts

@@ -1,10 +0,0 @@
-import { PackageJson } from '../../../../utils/package-json';
-/**
- * Get version of hoisted package if available
- */
-export declare function getHoistedPackageVersion(packageName: string): string;
-export type NormalizedPackageJson = Pick<PackageJson, 'name' | 'version' | 'license' | 'dependencies' | 'devDependencies' | 'peerDependencies' | 'peerDependenciesMeta' | 'optionalDependencies' | 'packageManager' | 'resolutions'>;
-/**
- * Strip off non-pruning related fields from package.json
- */
-export declare function normalizePackageJson(packageJson: PackageJson): NormalizedPackageJson;

package/src/plugins/js/lock-file/utils/package-json.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHoistedPackageVersion = getHoistedPackageVersion;
-exports.normalizePackageJson = normalizePackageJson;
-const fs_1 = require("fs");
-const workspace_root_1 = require("../../../../utils/workspace-root");
-/**
- * Get version of hoisted package if available
- */
-function getHoistedPackageVersion(packageName) {
-    const fullPath = `${workspace_root_1.workspaceRoot}/node_modules/${packageName}/package.json`;
-    if ((0, fs_1.existsSync)(fullPath)) {
-        const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
-        return JSON.parse(content)?.version;
-    }
-    return;
-}
-/**
- * Strip off non-pruning related fields from package.json
- */
-function normalizePackageJson(packageJson) {
-    const { name, version, license, dependencies, devDependencies, peerDependencies, peerDependenciesMeta, optionalDependencies, packageManager, resolutions, } = packageJson;
-    return {
-        name,
-        version,
-        license,
-        dependencies,
-        devDependencies,
-        peerDependencies,
-        peerDependenciesMeta,
-        optionalDependencies,
-        packageManager,
-        resolutions,
-    };
-}