@pnpm/installing.linking.real-hoist 1100.1.21 → 1100.1.22

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @pnpm/real-hoist
 
+## 1100.1.22
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/deps.path@1101.0.6
+  - @pnpm/error@1100.2.2
+  - @pnpm/lockfile.utils@1102.1.6
+
 ## 1100.1.21
 
 ### Patch Changes

package/lib/index.js

@@ -53,141 +53,168 @@ export function getHoistingLimits(lockfile, mode) {
     const hoistingLimits = new Map();
     const rootHoistingLimit = new Set();
     for (const [importerId, importer] of Object.entries(lockfile.importers)) {
-        const isWorkspaceRoot = importerId === '.';
-        const encodedId = encodeURIComponent(importerId);
-        if (!isWorkspaceRoot) {
-            rootHoistingLimit.add(encodedId);
-            if (mode !== 'dependencies') {
-                // In `'workspaces'` mode it's enough to border each workspace
-                // package at the root; their own direct deps don't need a
-                // per-importer border.
-                continue;
-            }
-        }
-        const reference = isWorkspaceRoot ? '' : `workspace:${importerId}`;
-        const hoistingLimit = isWorkspaceRoot ? rootHoistingLimit : new Set();
-        hoistingLimits.set(`${encodedId}@${reference}`, hoistingLimit);
-        for (const deps of [importer.dependencies, importer.devDependencies, importer.optionalDependencies]) {
-            if (!deps)
-                continue;
-            for (const dep of Object.keys(deps)) {
-                hoistingLimit.add(dep);
-            }
-        }
+        addImporterHoistingLimits({
+            hoistingLimits,
+            importer,
+            importerId,
+            mode,
+            rootHoistingLimit,
+        });
     }
     if (!hoistingLimits.has('.@')) {
         hoistingLimits.set('.@', rootHoistingLimit);
     }
     return hoistingLimits;
 }
+function addImporterHoistingLimits(opts) {
+    const { hoistingLimits, importer, importerId, mode, rootHoistingLimit } = opts;
+    const isWorkspaceRoot = importerId === '.';
+    const encodedId = encodeURIComponent(importerId);
+    if (!isWorkspaceRoot) {
+        rootHoistingLimit.add(encodedId);
+        if (mode !== 'dependencies') {
+            return;
+        }
+    }
+    const reference = isWorkspaceRoot ? '' : `workspace:${importerId}`;
+    const hoistingLimit = isWorkspaceRoot ? rootHoistingLimit : new Set();
+    hoistingLimits.set(`${encodedId}@${reference}`, hoistingLimit);
+    collectDirectDeps(importer, hoistingLimit);
+}
+function collectDirectDeps(importer, targetSet) {
+    const depGroups = [importer.dependencies, importer.devDependencies, importer.optionalDependencies];
+    for (const deps of depGroups) {
+        if (!deps)
+            continue;
+        for (const dep of Object.keys(deps)) {
+            targetSet.add(dep);
+        }
+    }
+}
 export function hoist(lockfile, opts) {
-    const nodes = new Map();
     const ctx = {
         autoInstallPeers: opts?.autoInstallPeers,
-        nodes,
-        lockfile,
         depPathByPkgId: new Map(),
+        lockfile,
+        nodes: new Map(),
     };
-    const _toTree = toTree.bind(null, ctx);
-    const node = {
-        name: '.',
-        identName: '.',
-        reference: '',
-        peerNames: new Set([]),
-        dependencyKind: HoisterDependencyKind.WORKSPACE,
-        dependencies: _toTree({
-            ...lockfile.importers['.']?.dependencies,
-            ...lockfile.importers['.']?.devDependencies,
-            ...lockfile.importers['.']?.optionalDependencies,
-            ...(Array.from(opts?.externalDependencies ?? [])).reduce((acc, dep) => {
-                // It doesn't matter what version spec is used here.
-                // This dependency will be removed from the tree anyway.
-                // It is only needed to prevent the hoister from hoisting deps with this name to the root of node_modules.
-                acc[dep] = 'link:';
-                return acc;
-            }, {}),
-        }),
-    };
+    const rootNode = buildRootHoisterTree(lockfile, ctx, opts?.externalDependencies);
     for (const [importerId, importer] of Object.entries(lockfile.importers)) {
         if (importerId === '.')
             continue;
-        const importerNode = {
-            name: encodeURIComponent(importerId),
-            identName: encodeURIComponent(importerId),
-            reference: `workspace:${importerId}`,
-            peerNames: new Set([]),
-            dependencyKind: HoisterDependencyKind.WORKSPACE,
-            dependencies: _toTree({
-                ...importer.dependencies,
-                ...importer.devDependencies,
-                ...importer.optionalDependencies,
-            }),
-        };
-        node.dependencies.add(importerNode);
+        rootNode.dependencies.add(buildImporterHoisterTree(importerId, importer, ctx));
     }
     const hoistingLimits = getHoistingLimits(lockfile, opts?.hoistingLimits);
-    const hoisterResult = _hoist(node, { ...opts, hoistingLimits });
+    const hoisterResult = _hoist(rootNode, { ...opts, hoistingLimits });
     if (opts?.externalDependencies) {
-        for (const hoistedDep of hoisterResult.dependencies.values()) {
-            if (opts.externalDependencies.has(hoistedDep.name)) {
-                hoisterResult.dependencies.delete(hoistedDep);
-            }
-        }
+        filterExternalDependencies(hoisterResult, opts.externalDependencies);
     }
     return hoisterResult;
 }
-function toTree({ nodes, lockfile, depPathByPkgId, autoInstallPeers }, deps) {
+function buildRootHoisterTree(lockfile, ctx, externalDependencies) {
+    const rootImporter = lockfile.importers['.'];
+    const externalDepsMap = {};
+    for (const dep of externalDependencies ?? []) {
+        externalDepsMap[dep] = 'link:';
+    }
+    return {
+        dependencies: toTree(ctx, {
+            ...rootImporter?.dependencies,
+            ...rootImporter?.devDependencies,
+            ...rootImporter?.optionalDependencies,
+            ...externalDepsMap,
+        }),
+        dependencyKind: HoisterDependencyKind.WORKSPACE,
+        identName: '.',
+        name: '.',
+        peerNames: new Set([]),
+        reference: '',
+    };
+}
+function buildImporterHoisterTree(importerId, importer, ctx) {
+    return {
+        dependencies: toTree(ctx, {
+            ...importer.dependencies,
+            ...importer.devDependencies,
+            ...importer.optionalDependencies,
+        }),
+        dependencyKind: HoisterDependencyKind.WORKSPACE,
+        identName: encodeURIComponent(importerId),
+        name: encodeURIComponent(importerId),
+        peerNames: new Set([]),
+        reference: `workspace:${importerId}`,
+    };
+}
+function filterExternalDependencies(result, externalDependencies) {
+    for (const hoistedDep of result.dependencies.values()) {
+        if (externalDependencies.has(hoistedDep.name)) {
+            result.dependencies.delete(hoistedDep);
+        }
+    }
+}
+function toTree(ctx, deps) {
     return new Set(Object.entries(deps).map(([alias, ref]) => {
         const depPath = dp.refToRelative(ref, alias);
         if (!depPath) {
-            const key = `${alias}:${ref}`;
-            let node = nodes.get(key);
-            if (!node) {
-                node = {
-                    name: alias,
-                    identName: alias,
-                    reference: ref,
-                    // A link into the declaring package must stay next to that package,
-                    // and the hoister never moves a workspace node.
-                    dependencyKind: dp.packageRootLinkTarget(ref) != null
-                        ? HoisterDependencyKind.WORKSPACE
-                        : HoisterDependencyKind.REGULAR,
-                    dependencies: new Set(),
-                    peerNames: new Set(),
-                };
-                nodes.set(key, node);
-            }
-            return node;
-        }
-        const key = `${alias}:${depPath}`;
-        let node = nodes.get(key);
-        if (!node) {
-            const pkgSnapshot = lockfile.packages[depPath];
-            if (!pkgSnapshot) {
-                throw new LockfileMissingDependencyError(depPath);
-            }
-            const { name: pkgName } = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
-            const id = getHoisterPkgId(depPath, pkgSnapshot);
-            if (!depPathByPkgId.has(id)) {
-                depPathByPkgId.set(id, depPath);
-            }
-            node = {
-                name: alias,
-                identName: pkgName,
-                reference: depPathByPkgId.get(id),
-                dependencyKind: HoisterDependencyKind.REGULAR,
-                dependencies: new Set(),
-                peerNames: new Set(autoInstallPeers
-                    ? []
-                    : [
-                        ...Object.keys(pkgSnapshot.peerDependencies ?? {}),
-                        ...(pkgSnapshot.transitivePeerDependencies ?? []),
-                    ]),
-            };
-            nodes.set(key, node);
-            node.dependencies = toTree({ nodes, lockfile, depPathByPkgId, autoInstallPeers }, { ...pkgSnapshot.dependencies, ...pkgSnapshot.optionalDependencies });
+            return getOrCreateWorkspaceNode(ctx.nodes, alias, ref);
         }
-        return node;
+        return getOrCreatePackageNode(ctx, alias, depPath);
     }));
 }
+function getOrCreateWorkspaceNode(nodes, alias, ref) {
+    const key = `${alias}:${ref}`;
+    let node = nodes.get(key);
+    if (!node) {
+        node = {
+            dependencies: new Set(),
+            dependencyKind: dp.packageRootLinkTarget(ref) != null
+                ? HoisterDependencyKind.WORKSPACE
+                : HoisterDependencyKind.REGULAR,
+            identName: alias,
+            name: alias,
+            peerNames: new Set(),
+            reference: ref,
+        };
+        nodes.set(key, node);
+    }
+    return node;
+}
+function getOrCreatePackageNode(ctx, alias, depPath) {
+    const key = `${alias}:${depPath}`;
+    let node = ctx.nodes.get(key);
+    if (!node) {
+        const pkgSnapshot = ctx.lockfile.packages?.[depPath];
+        if (!pkgSnapshot) {
+            throw new LockfileMissingDependencyError(depPath);
+        }
+        const { name: pkgName } = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
+        const id = getHoisterPkgId(depPath, pkgSnapshot);
+        if (!ctx.depPathByPkgId.has(id)) {
+            ctx.depPathByPkgId.set(id, depPath);
+        }
+        node = {
+            dependencies: new Set(),
+            dependencyKind: HoisterDependencyKind.REGULAR,
+            identName: pkgName,
+            name: alias,
+            peerNames: resolvePeerNames(pkgSnapshot, ctx.autoInstallPeers),
+            reference: ctx.depPathByPkgId.get(id),
+        };
+        ctx.nodes.set(key, node);
+        node.dependencies = toTree(ctx, {
+            ...pkgSnapshot.dependencies,
+            ...pkgSnapshot.optionalDependencies,
+        });
+    }
+    return node;
+}
+function resolvePeerNames(pkgSnapshot, autoInstallPeers) {
+    if (autoInstallPeers) {
+        return new Set();
+    }
+    return new Set([
+        ...Object.keys(pkgSnapshot.peerDependencies ?? {}),
+        ...(pkgSnapshot.transitivePeerDependencies ?? []),
+    ]);
+}
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/installing.linking.real-hoist",
-  "version": "1100.1.21",
+  "version": "1100.1.22",
   "description": "Hoists dependencies in a node_modules created by pnpm",
   "keywords": [
     "pnpm",
@@ -27,16 +27,16 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/deps.path": "1101.0.5",
-    "@pnpm/error": "1100.2.1",
+    "@pnpm/deps.path": "1101.0.6",
+    "@pnpm/error": "1100.2.2",
     "@pnpm/lockfile.types": "1100.1.4",
-    "@pnpm/lockfile.utils": "1102.1.5",
+    "@pnpm/lockfile.utils": "1102.1.6",
     "@yarnpkg/nm": "4.1.1"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/installing.linking.real-hoist": "1100.1.21",
-    "@pnpm/lockfile.fs": "1100.2.10",
+    "@pnpm/installing.linking.real-hoist": "1100.1.22",
+    "@pnpm/lockfile.fs": "1100.2.13",
     "@pnpm/test-fixtures": "1100.0.1",
     "@pnpm/types": "1102.1.1"
   },