@pnpm/installing.linking.hoist 1002.0.8

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @pnpm/hoist
+
+> Hoists dependencies in a node_modules created by pnpm
+
+Formerly `@pnpm/shamefully-flatten`.
+
+## Installation
+
+```
+pnpm add @pnpm/hoist
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,71 @@
+import type { DependenciesField, DepPath, HoistedDependencies, ProjectId } from '@pnpm/types';
+export interface DependenciesGraphNode<T extends string> {
+    dir: string;
+    children: Record<string, T>;
+    optionalDependencies: Set<string>;
+    hasBin: boolean;
+    name: string;
+    depPath: DepPath;
+}
+export type DependenciesGraph<T extends string> = Record<T, DependenciesGraphNode<T>>;
+export interface DirectDependenciesByImporterId<T extends string> {
+    [importerId: string]: Map<string, T>;
+}
+export interface HoistOpts<T extends string> extends GetHoistedDependenciesOpts<T> {
+    extraNodePath?: string[];
+    preferSymlinkedExecutables?: boolean;
+    virtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+}
+export declare function hoist<T extends string>(opts: HoistOpts<T>): Promise<HoistedDependencies | null>;
+export interface GetHoistedDependenciesOpts<T extends string> {
+    graph: DependenciesGraph<T>;
+    skipped: Set<DepPath>;
+    directDepsByImporterId: DirectDependenciesByImporterId<T>;
+    importerIds?: ProjectId[];
+    privateHoistPattern: string[];
+    privateHoistedModulesDir: string;
+    publicHoistPattern: string[];
+    publicHoistedModulesDir: string;
+    hoistedWorkspacePackages?: Record<ProjectId, HoistedWorkspaceProject>;
+}
+export interface HoistedWorkspaceProject {
+    name: string;
+    dir: string;
+}
+export declare function getHoistedDependencies<T extends string>(opts: GetHoistedDependenciesOpts<T>): HoistGraphResult<T> | null;
+export interface Dependency<T extends string> {
+    children: Record<string, T | ProjectId>;
+    nodeId: T;
+    depth: number;
+}
+interface HoistGraphResult<T extends string> {
+    hoistedDependencies: HoistedDependencies;
+    hoistedDependenciesByNodeId: HoistedDependenciesByNodeId<T>;
+    hoistedAliasesWithBins: string[];
+}
+type HoistedDependenciesByNodeId<T extends string> = Map<T | ProjectId, Record<string, 'public' | 'private'>>;
+export declare function graphWalker<T extends string>(graph: DependenciesGraph<T>, directDepsByImporterId: DirectDependenciesByImporterId<T>, opts?: {
+    include?: {
+        [dependenciesField in DependenciesField]: boolean;
+    };
+    skipped?: Set<DepPath>;
+}): GraphWalker<T>;
+export interface GraphWalker<T extends string> {
+    directDeps: Array<{
+        alias: string;
+        nodeId: T;
+    }>;
+    step: GraphWalkerStep<T>;
+}
+export interface GraphWalkerStep<T extends string> {
+    dependencies: Array<GraphDependency<T>>;
+    links: string[];
+    missing: string[];
+}
+export interface GraphDependency<T extends string> {
+    nodeId: T;
+    node: DependenciesGraphNode<T>;
+    next: () => GraphWalkerStep<T>;
+}
+export {};

package/lib/index.js

@@ -0,0 +1,305 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { linkBinsOfPkgsByAliases } from '@pnpm/bins.linker';
+import { createMatcher } from '@pnpm/config.matcher';
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { linkLogger } from '@pnpm/core-loggers';
+import { logger } from '@pnpm/logger';
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import { isSubdir } from 'is-subdir';
+import { resolveLinkTarget } from 'resolve-link-target';
+import symlinkDir from 'symlink-dir';
+const hoistLogger = logger('hoist');
+export async function hoist(opts) {
+    const result = getHoistedDependencies(opts);
+    if (!result)
+        return null;
+    const { hoistedDependencies, hoistedAliasesWithBins, hoistedDependenciesByNodeId } = result;
+    await symlinkHoistedDependencies(hoistedDependenciesByNodeId, {
+        graph: opts.graph,
+        directDepsByImporterId: opts.directDepsByImporterId,
+        privateHoistedModulesDir: opts.privateHoistedModulesDir,
+        publicHoistedModulesDir: opts.publicHoistedModulesDir,
+        virtualStoreDir: opts.virtualStoreDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        hoistedWorkspacePackages: opts.hoistedWorkspacePackages,
+    });
+    // Here we only link the bins of the privately hoisted modules.
+    // The bins of the publicly hoisted modules will be linked together with
+    // the bins of the project's direct dependencies.
+    // This is possible because the publicly hoisted modules
+    // are in the same directory as the regular dependencies.
+    await linkAllBins(opts.privateHoistedModulesDir, {
+        extraNodePaths: opts.extraNodePath,
+        hoistedAliasesWithBins,
+        preferSymlinkedExecutables: opts.preferSymlinkedExecutables,
+    });
+    return hoistedDependencies;
+}
+export function getHoistedDependencies(opts) {
+    if (Object.keys(opts.graph ?? {}).length === 0)
+        return null;
+    const { directDeps, step } = graphWalker(opts.graph, opts.directDepsByImporterId);
+    // We want to hoist all the workspace packages, not only those that are in the dependencies
+    // of any other workspace packages.
+    // That is why we can't just simply use the lockfile walker to include links to local workspace packages too.
+    // We have to explicitly include all the workspace packages.
+    const hoistedWorkspaceDeps = Object.fromEntries(Object.entries(opts.hoistedWorkspacePackages ?? {})
+        .map(([id, { name }]) => [name, id]));
+    const deps = [
+        {
+            children: {
+                ...hoistedWorkspaceDeps,
+                ...directDeps
+                    .reduce((acc, { alias, nodeId }) => {
+                    if (!acc[alias]) {
+                        acc[alias] = nodeId;
+                    }
+                    return acc;
+                }, {}),
+            },
+            nodeId: '',
+            depth: -1,
+        },
+        ...getDependencies(0, step),
+    ];
+    const getAliasHoistType = createGetAliasHoistType(opts.publicHoistPattern, opts.privateHoistPattern);
+    return hoistGraph(deps, opts.directDepsByImporterId['.'] ?? new Map(), {
+        getAliasHoistType,
+        graph: opts.graph,
+        skipped: opts.skipped,
+    });
+}
+function createGetAliasHoistType(publicHoistPattern, privateHoistPattern) {
+    const publicMatcher = createMatcher(publicHoistPattern);
+    const privateMatcher = createMatcher(privateHoistPattern);
+    return (alias) => {
+        if (publicMatcher(alias))
+            return 'public';
+        if (privateMatcher(alias))
+            return 'private';
+        return false;
+    };
+}
+async function linkAllBins(modulesDir, opts) {
+    const bin = path.join(modulesDir, '.bin');
+    const warn = (message, code) => {
+        if (code === 'BINARIES_CONFLICT')
+            return;
+        logger.info({ message, prefix: path.join(modulesDir, '../..') });
+    };
+    try {
+        await linkBinsOfPkgsByAliases(opts.hoistedAliasesWithBins, bin, {
+            allowExoticManifests: true,
+            extraNodePaths: opts.extraNodePaths,
+            modulesDir,
+            preferSymlinkedExecutables: opts.preferSymlinkedExecutables,
+            warn,
+        });
+    }
+    catch (err) { // eslint-disable-line
+        // Some packages generate their commands with lifecycle hooks.
+        // At this stage, such commands are not generated yet.
+        // For now, we don't hoist such generated commands.
+        // Related issue: https://github.com/pnpm/pnpm/issues/2071
+    }
+}
+function getDependencies(depth, step) {
+    const deps = [];
+    const nextSteps = [];
+    for (const { node, nodeId, next } of step.dependencies) {
+        deps.push({
+            children: node.children,
+            nodeId,
+            depth,
+        });
+        nextSteps.push(next());
+    }
+    for (const depPath of step.missing) {
+        // It might make sense to fail if the depPath is not in the skipped list from .modules.yaml
+        // However, the skipped list currently contains package IDs, not dep paths.
+        logger.debug({ message: `No entry for "${depPath}" in ${WANTED_LOCKFILE}` });
+    }
+    return [
+        ...deps,
+        ...nextSteps.flatMap(getDependencies.bind(null, depth + 1)),
+    ];
+}
+function hoistGraph(depNodes, currentSpecifiers, opts) {
+    const hoistedAliases = new Set(currentSpecifiers.keys());
+    const hoistedDependencies = Object.create(null);
+    const hoistedDependenciesByNodeId = new Map();
+    const hoistedAliasesWithBins = new Set();
+    depNodes
+        // sort by depth and then alphabetically
+        .sort((a, b) => {
+        const depthDiff = a.depth - b.depth;
+        return depthDiff === 0 ? lexCompare(a.nodeId, b.nodeId) : depthDiff;
+    })
+        // build the alias map and the id map
+        .forEach((depNode) => {
+        for (const [childAlias, childNodeId] of Object.entries(depNode.children)) {
+            const hoist = opts.getAliasHoistType(childAlias);
+            if (!hoist)
+                continue;
+            const childAliasNormalized = childAlias.toLowerCase();
+            // if this alias has already been taken, skip it
+            if (hoistedAliases.has(childAliasNormalized)) {
+                continue;
+            }
+            if (!hoistedDependenciesByNodeId.has(childNodeId)) {
+                hoistedDependenciesByNodeId.set(childNodeId, {});
+            }
+            hoistedDependenciesByNodeId.get(childNodeId)[childAlias] = hoist;
+            const node = opts.graph[childNodeId];
+            if (node?.depPath == null || opts.skipped.has(node.depPath)) {
+                continue;
+            }
+            if (node.hasBin) {
+                hoistedAliasesWithBins.add(childAlias);
+            }
+            hoistedAliases.add(childAliasNormalized);
+            if (!hoistedDependencies[node.depPath]) {
+                hoistedDependencies[node.depPath] = {};
+            }
+            hoistedDependencies[node.depPath][childAlias] = hoist;
+        }
+    });
+    return {
+        hoistedDependencies,
+        hoistedDependenciesByNodeId,
+        hoistedAliasesWithBins: Array.from(hoistedAliasesWithBins),
+    };
+}
+async function symlinkHoistedDependencies(hoistedDependenciesByNodeId, opts) {
+    const symlink = symlinkHoistedDependency.bind(null, opts);
+    const promises = [];
+    for (const [hoistedDepNodeId, pkgAliases] of hoistedDependenciesByNodeId.entries()) {
+        promises.push((async () => {
+            const node = opts.graph[hoistedDepNodeId];
+            let depLocation;
+            if (node) {
+                depLocation = node.dir;
+            }
+            else {
+                if (!opts.directDepsByImporterId[hoistedDepNodeId]) {
+                    // This dependency is probably a skipped optional dependency.
+                    hoistLogger.debug({ hoistFailedFor: hoistedDepNodeId });
+                    return;
+                }
+                depLocation = opts.hoistedWorkspacePackages[hoistedDepNodeId].dir;
+            }
+            await Promise.all(Object.entries(pkgAliases).map(async ([pkgAlias, hoistType]) => {
+                const targetDir = hoistType === 'public'
+                    ? opts.publicHoistedModulesDir
+                    : opts.privateHoistedModulesDir;
+                const dest = path.join(targetDir, pkgAlias);
+                return symlink(depLocation, dest);
+            }));
+        })());
+    }
+    await Promise.all(promises);
+}
+async function symlinkHoistedDependency(opts, depLocation, dest) {
+    try {
+        await symlinkDir(depLocation, dest, { overwrite: false });
+        linkLogger.debug({ target: dest, link: depLocation });
+        return;
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'EEXIST' && err.code !== 'EISDIR')
+            throw err;
+    }
+    let existingSymlink;
+    try {
+        existingSymlink = await resolveLinkTarget(dest);
+    }
+    catch {
+        hoistLogger.debug({
+            skipped: dest,
+            reason: 'a directory is present at the target location',
+        });
+        return;
+    }
+    if (!isSubdir(opts.virtualStoreDir, existingSymlink)) {
+        hoistLogger.debug({
+            skipped: dest,
+            existingSymlink,
+            reason: 'an external symlink is present at the target location',
+        });
+        return;
+    }
+    await fs.promises.unlink(dest);
+    await symlinkDir(depLocation, dest);
+    linkLogger.debug({ target: dest, link: depLocation });
+}
+export function graphWalker(graph, directDepsByImporterId, opts) {
+    const startNodeIds = [];
+    const allDirectDeps = [];
+    for (const directDeps of Object.values(directDepsByImporterId)) {
+        for (const [alias, nodeId] of directDeps.entries()) {
+            const depNode = graph[nodeId];
+            if (depNode == null)
+                continue;
+            startNodeIds.push(nodeId);
+            allDirectDeps.push({ alias, nodeId });
+        }
+    }
+    const visited = new Set();
+    return {
+        directDeps: allDirectDeps,
+        step: makeStep({
+            includeOptionalDependencies: opts?.include?.optionalDependencies !== false,
+            graph,
+            visited,
+            skipped: opts?.skipped,
+        }, startNodeIds),
+    };
+}
+function makeStep(ctx, nextNodeIds) {
+    const result = {
+        dependencies: [],
+        links: [],
+        missing: [],
+    };
+    const _next = collectChildNodeIds.bind(null, {
+        includeOptionalDependencies: ctx.includeOptionalDependencies,
+    });
+    for (const nodeId of nextNodeIds) {
+        if (ctx.visited.has(nodeId))
+            continue;
+        ctx.visited.add(nodeId);
+        const node = ctx.graph[nodeId];
+        if (node == null) {
+            if (nodeId.startsWith('link:')) {
+                result.links.push(nodeId);
+                continue;
+            }
+            result.missing.push(nodeId);
+            continue;
+        }
+        if (ctx.skipped?.has(node.depPath))
+            continue;
+        result.dependencies.push({
+            nodeId,
+            next: () => makeStep(ctx, _next(node)),
+            node,
+        });
+    }
+    return result;
+}
+function collectChildNodeIds(opts, nextPkg) {
+    if (opts.includeOptionalDependencies) {
+        return Object.values(nextPkg.children);
+    }
+    else {
+        const nextNodeIds = [];
+        for (const [alias, nodeId] of Object.entries(nextPkg.children)) {
+            if (!nextPkg.optionalDependencies.has(alias)) {
+                nextNodeIds.push(nodeId);
+            }
+        }
+        return nextNodeIds;
+    }
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@pnpm/installing.linking.hoist",
+  "version": "1002.0.8",
+  "description": "Hoists dependencies in a node_modules created by pnpm",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/installing/linking/hoist",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/installing/linking/hoist#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@pnpm/util.lex-comparator": "^3.0.2",
+    "is-subdir": "^2.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "resolve-link-target": "^3.0.0",
+    "symlink-dir": "^7.0.0",
+    "@pnpm/bins.linker": "1000.2.6",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/config.matcher": "1000.1.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@types/ramda": "0.29.12",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/installing.linking.hoist": "1002.0.8"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "test": "pnpm run compile",
+    "lint": "eslint \"src/**/*.ts\"",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}