@pnpm/installing.deps-resolver 1100.2.2 → 1100.2.4

package/lib/dedupeInjectedDeps.js

@@ -27,19 +27,26 @@ function getDedupeMap(injectedDepsByProjects, opts) {
     for (const [id, deps] of injectedDepsByProjects.entries()) {
         const dedupedInjectedDeps = new Map();
         for (const [alias, dep] of deps.entries()) {
-            // Check for subgroup not equal.
-            // The injected project in the workspace may have dev deps
-            const children = Object.entries(opts.depGraph[dep.depPath].children);
+            const node = opts.depGraph[dep.depPath];
             const targetProjectDeps = opts.dependenciesByProjectId[dep.id];
-            // When the target project wasn't part of the current resolution (e.g. single-project
-            // operation), its dependencies aren't available. We can only deduplicate safely when the
-            // injected dep has no children (the empty set is always a subset).
+            // In single-project operations (e.g. `pnpm rm` from inside a workspace package) the target
+            // workspace project isn't being resolved, so its children aren't in
+            // `dependenciesByProjectId`. The injected dep was resolved against the same workspace
+            // package source, so dedupe is safe. The exception is peer-suffixed depPaths, whose
+            // resolution depends on the importer's peer context. A plain `link:` would lose that, so
+            // we skip dedupe for those. A depPath is `${pkgIdWithPatchHash}${peerDepGraphHash}`, so it
+            // carries a peer suffix exactly when it differs from its peer-free `pkgIdWithPatchHash`.
             if (!targetProjectDeps) {
-                if (children.length > 0)
-                    continue;
+                if (node.pkgIdWithPatchHash === dep.depPath) {
+                    dedupedInjectedDeps.set(alias, dep.id);
+                }
+                continue;
             }
+            // Check for subgroup not equal.
+            // The injected project in the workspace may have dev deps
+            const children = Object.entries(node.children);
             const isSubset = children
-                .every(([alias, depPath]) => targetProjectDeps?.get(alias) === depPath);
+                .every(([alias, depPath]) => targetProjectDeps.get(alias) === depPath);
             if (isSubset) {
                 dedupedInjectedDeps.set(alias, dep.id);
             }

package/lib/index.d.ts

@@ -9,6 +9,7 @@ import { type DependenciesByProjectId, type GenericDependenciesGraphNodeWithReso
 export type DependenciesGraph = GenericDependenciesGraphWithResolvedChildren<ResolvedPackage>;
 export type DependenciesGraphNode = GenericDependenciesGraphNodeWithResolvedChildren & ResolvedPackage;
 export { getWantedDependencies, type LinkedDependency, type PinnedVersion, type ResolvedPackage, type UpdateMatchingFunction, type WantedDependency, };
+export { assertValidDependencyAliases, isValidDependencyAlias } from './validateDependencyAlias.js';
 export interface ImporterToResolve extends Importer<{
     isNew?: boolean;
     nodeExecPath?: string;

package/lib/index.js

@@ -19,6 +19,7 @@ import { toResolveImporter } from './toResolveImporter.js';
 import { updateLockfile } from './updateLockfile.js';
 import { updateProjectManifest } from './updateProjectManifest.js';
 export { getWantedDependencies, };
+export { assertValidDependencyAliases, isValidDependencyAlias } from './validateDependencyAlias.js';
 export async function resolveDependencies(importers, opts) {
     const _toResolveImporter = toResolveImporter.bind(null, {
         defaultUpdateDepth: opts.defaultUpdateDepth,

package/lib/resolveDependencies.d.ts

@@ -87,7 +87,12 @@ export interface ResolutionContext {
     resolvedPkgsById: ResolvedPkgsById;
     resolvePeersFromWorkspaceRoot?: boolean;
     outdatedDependencies: Record<PkgResolutionId, string>;
+    packageResolutionBarrier: PackageResolutionBarrier;
     childrenByParentId: ChildrenByParentId;
+    childrenResolutionByPkgId: Record<PkgResolutionId, ChildrenResolution>;
+    childrenResolutionId: number;
+    importerResolutionOrder: Record<string, number>;
+    nodeResolutionContextByNodeId: Map<NodeId, NodeResolutionContext>;
     patchedDependencies?: PatchGroupRecord;
     pendingNodes: PendingNode[];
     wantedLockfile: LockfileObject;
@@ -132,6 +137,26 @@ export interface ResolutionContext {
     trustPolicyIgnoreAfter?: number;
     blockExoticSubdeps?: boolean;
 }
+interface PackageResolutionBarrier {
+    activeByDepth: Map<number, number>;
+    waiters: Array<() => void>;
+}
+interface ChildrenResolutionOwner {
+    depth: number;
+    importerOrder: number;
+    parentPath: PkgResolutionId[];
+}
+interface ChildrenResolution {
+    id: number;
+    owner: ChildrenResolutionOwner;
+    missingPeersOfChildren?: MissingPeersOfChildren;
+}
+interface NodeResolutionContext {
+    depth: number;
+    installable: boolean;
+    parentIds: PkgResolutionId[];
+    pkgId: PkgResolutionId;
+}
 export interface MissingPeerInfo {
     range: string;
     optional: boolean;
@@ -156,6 +181,7 @@ export interface PkgAddress extends PkgAddressOrLinkBase {
     rootDir: string;
     missingPeers: MissingPeers;
     missingPeersOfChildren?: MissingPeersOfChildren;
+    childrenResolutionId?: number;
     publishedAt?: string;
     saveCatalogName?: string;
     lockedPeerContext?: LockedPeerContext;
@@ -252,6 +278,15 @@ export declare function resolveDependencies(ctx: ResolutionContext, preferredVer
     updateDepth?: number;
 }>, options: ResolvedDependenciesOptions): Promise<ResolvedDependenciesResult>;
 export declare function createNodeIdForLinkedLocalPkg(lockfileDir: string, pkgDir: string): NodeId;
+export declare function buildTree(ctx: {
+    childrenByParentId: ChildrenByParentId;
+    dependenciesTree: DependenciesTree<ResolvedPackage>;
+    resolvedPkgsById: ResolvedPkgsById;
+    skipped: Set<PkgResolutionId>;
+}, parentId: PkgResolutionId, parentIds: PkgResolutionId[], children: Array<{
+    alias: string;
+    id: PkgResolutionId;
+}>, depth: number, installable: boolean): Record<string, NodeId>;
 export interface LockedPeerContext {
     [peerName: string]: DepPath;
 }