@pnpm/installing.deps-resolver 1008.3.1

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,17 @@
+# @pnpm/installing.deps-resolver
+
+> Resolves dependency graph of a package
+
+## Install
+
+```
+pnpm install @pnpm/installing.deps-resolver
+```
+
+## API
+
+### `resolveDependencies(...args)`
+
+## License
+
+MIT

package/lib/dedupeInjectedDeps.d.ts

@@ -0,0 +1,14 @@
+import type { DepPath } from '@pnpm/types';
+import type { NodeId } from './nextNodeId.js';
+import type { ResolvedImporters } from './resolveDependencyTree.js';
+import type { DependenciesByProjectId, GenericDependenciesGraphWithResolvedChildren, PartialResolvedPackage, ProjectToResolve } from './resolvePeers.js';
+export interface DedupeInjectedDepsOptions<T extends PartialResolvedPackage> {
+    depGraph: GenericDependenciesGraphWithResolvedChildren<T>;
+    dependenciesByProjectId: DependenciesByProjectId;
+    lockfileDir: string;
+    pathsByNodeId: Map<NodeId, DepPath>;
+    projects: ProjectToResolve[];
+    resolvedImporters: ResolvedImporters;
+    workspaceProjectIds: Set<string>;
+}
+export declare function dedupeInjectedDeps<T extends PartialResolvedPackage>(opts: DedupeInjectedDepsOptions<T>): void;

package/lib/dedupeInjectedDeps.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import normalize from 'normalize-path';
+export function dedupeInjectedDeps(opts) {
+    const injectedDepsByProjects = getInjectedDepsByProjects(opts);
+    const dedupeMap = getDedupeMap(injectedDepsByProjects, opts);
+    applyDedupeMap(dedupeMap, opts);
+}
+function getInjectedDepsByProjects(opts) {
+    const injectedDepsByProjects = new Map();
+    for (const project of opts.projects) {
+        for (const [alias, nodeId] of project.directNodeIdsByAlias.entries()) {
+            const depPath = opts.pathsByNodeId.get(nodeId);
+            if (!opts.depGraph[depPath].id.startsWith('file:'))
+                continue;
+            const id = opts.depGraph[depPath].id.substring(5);
+            if (opts.workspaceProjectIds.has(id)) {
+                if (!injectedDepsByProjects.has(project.id))
+                    injectedDepsByProjects.set(project.id, new Map());
+                injectedDepsByProjects.get(project.id).set(alias, { depPath, id });
+            }
+        }
+    }
+    return injectedDepsByProjects;
+}
+function getDedupeMap(injectedDepsByProjects, opts) {
+    const toDedupe = new Map();
+    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 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).
+            if (!targetProjectDeps) {
+                if (children.length > 0)
+                    continue;
+            }
+            const isSubset = children
+                .every(([alias, depPath]) => targetProjectDeps?.get(alias) === depPath);
+            if (isSubset) {
+                dedupedInjectedDeps.set(alias, dep.id);
+            }
+        }
+        toDedupe.set(id, dedupedInjectedDeps);
+    }
+    return toDedupe;
+}
+function applyDedupeMap(dedupeMap, opts) {
+    for (const [id, aliases] of dedupeMap.entries()) {
+        for (const [alias, dedupedProjectId] of aliases.entries()) {
+            opts.dependenciesByProjectId[id].delete(alias);
+            const index = opts.resolvedImporters[id].directDependencies.findIndex((dep) => dep.alias === alias);
+            const prev = opts.resolvedImporters[id].directDependencies[index];
+            const linkedDep = {
+                ...prev,
+                pkg: prev,
+                isLinkedDependency: true,
+                pkgId: `link:${normalize(path.relative(id, dedupedProjectId))}`,
+                resolution: {
+                    type: 'directory',
+                    directory: path.join(opts.lockfileDir, dedupedProjectId),
+                },
+            };
+            opts.resolvedImporters[id].directDependencies[index] = linkedDep;
+            opts.resolvedImporters[id].linkedDependencies.push(linkedDep);
+        }
+    }
+}
+//# sourceMappingURL=dedupeInjectedDeps.js.map

package/lib/depPathToRef.d.ts

@@ -0,0 +1,4 @@
+export declare function depPathToRef(depPath: string, opts: {
+    alias: string;
+    realName: string;
+}): string;

package/lib/depPathToRef.js

@@ -0,0 +1,7 @@
+export function depPathToRef(depPath, opts) {
+    if (opts.alias === opts.realName && depPath.startsWith(`${opts.realName}@`)) {
+        return depPath.substring(opts.realName.length + 1);
+    }
+    return depPath;
+}
+//# sourceMappingURL=depPathToRef.js.map

package/lib/getCatalogSnapshots.d.ts

@@ -0,0 +1,4 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import type { CatalogSnapshots } from '@pnpm/lockfile.types';
+import type { ResolvedDirectDependency } from './resolveDependencyTree.js';
+export declare function getCatalogSnapshots(resolvedDirectDeps: readonly ResolvedDirectDependency[], updatedCatalogs?: Catalogs): CatalogSnapshots;

package/lib/getCatalogSnapshots.js

@@ -0,0 +1,21 @@
+export function getCatalogSnapshots(resolvedDirectDeps, updatedCatalogs) {
+    const catalogSnapshots = {};
+    const catalogedDeps = resolvedDirectDeps.filter(isCatalogedDep);
+    for (const dep of catalogedDeps) {
+        const snapshotForSingleCatalog = (catalogSnapshots[dep.catalogLookup.catalogName] ??= {});
+        const updatedSpecifier = updatedCatalogs?.[dep.catalogLookup.catalogName]?.[dep.alias];
+        snapshotForSingleCatalog[dep.alias] = {
+            // The "updated specifier" will be present when pnpm add/update is ran and
+            // bare specifiers need to be added in the pnpm-workspace.yaml file. When
+            // this happens, the updated specifier should be saved to lockfile instead
+            // of the original specifier before the update.
+            specifier: updatedSpecifier ?? dep.catalogLookup.specifier,
+            version: dep.version,
+        };
+    }
+    return catalogSnapshots;
+}
+function isCatalogedDep(dep) {
+    return dep.catalogLookup != null;
+}
+//# sourceMappingURL=getCatalogSnapshots.js.map

package/lib/getExactSinglePreferredVersions.d.ts

@@ -0,0 +1,6 @@
+import type { PreferredVersions } from '@pnpm/resolving.resolver-base';
+import type { WantedDependency } from './getWantedDependencies.js';
+/**
+ * Create a PreferredVersions object with a specific exact version.
+ */
+export declare function getExactSinglePreferredVersions(wantedDependency: WantedDependency, version: string): PreferredVersions;

package/lib/getExactSinglePreferredVersions.js

@@ -0,0 +1,11 @@
+import { unwrapPackageName } from './unwrapPackageName.js';
+/**
+ * Create a PreferredVersions object with a specific exact version.
+ */
+export function getExactSinglePreferredVersions(wantedDependency, version) {
+    const { pkgName } = unwrapPackageName(wantedDependency.alias, wantedDependency.bareSpecifier);
+    return {
+        [pkgName]: { [version]: 'version' },
+    };
+}
+//# sourceMappingURL=getExactSinglePreferredVersions.js.map

package/lib/getNonDevWantedDependencies.d.ts

@@ -0,0 +1,12 @@
+import type { DependencyManifest } from '@pnpm/types';
+export interface WantedDependency {
+    alias: string;
+    bareSpecifier: string;
+    dev: boolean;
+    optional: boolean;
+    injected?: boolean;
+    saveCatalogName?: string;
+}
+type GetNonDevWantedDependenciesManifest = Pick<DependencyManifest, 'bundleDependencies' | 'bundledDependencies' | 'optionalDependencies' | 'dependencies' | 'dependenciesMeta'>;
+export declare function getNonDevWantedDependencies(pkg: GetNonDevWantedDependenciesManifest): WantedDependency[];
+export {};

package/lib/getNonDevWantedDependencies.js

@@ -0,0 +1,29 @@
+import { pickBy } from 'ramda';
+export function getNonDevWantedDependencies(pkg) {
+    let bd = pkg.bundledDependencies ?? pkg.bundleDependencies;
+    if (bd === true) {
+        bd = pkg.dependencies != null ? Object.keys(pkg.dependencies) : [];
+    }
+    const bundledDeps = new Set(Array.isArray(bd) ? bd : []);
+    const filterDeps = getNotBundledDeps.bind(null, bundledDeps);
+    return getWantedDependenciesFromGivenSet(filterDeps({ ...pkg.optionalDependencies, ...pkg.dependencies }), {
+        dependenciesMeta: pkg.dependenciesMeta ?? {},
+        devDependencies: {},
+        optionalDependencies: pkg.optionalDependencies ?? {},
+    });
+}
+function getWantedDependenciesFromGivenSet(deps, opts) {
+    if (!deps)
+        return [];
+    return Object.entries(deps).map(([alias, bareSpecifier]) => ({
+        alias,
+        dev: !!opts.devDependencies[alias],
+        injected: opts.dependenciesMeta[alias]?.injected,
+        optional: !!opts.optionalDependencies[alias],
+        bareSpecifier,
+    }));
+}
+function getNotBundledDeps(bundledDeps, deps) {
+    return pickBy((_, depName) => !bundledDeps.has(depName), deps);
+}
+//# sourceMappingURL=getNonDevWantedDependencies.js.map

package/lib/getWantedDependencies.d.ts

@@ -0,0 +1,14 @@
+import type { IncludedDependencies, ProjectManifest } from '@pnpm/types';
+export interface WantedDependency {
+    alias: string;
+    bareSpecifier: string;
+    dev: boolean;
+    optional: boolean;
+    saveCatalogName?: string;
+    updateSpec?: boolean;
+    prevSpecifier?: string;
+}
+export declare function getWantedDependencies(pkg: Pick<ProjectManifest, 'devDependencies' | 'dependencies' | 'optionalDependencies' | 'dependenciesMeta' | 'peerDependencies'>, opts?: {
+    autoInstallPeers?: boolean;
+    includeDirect?: IncludedDependencies;
+}): WantedDependency[];

package/lib/getWantedDependencies.js

@@ -0,0 +1,45 @@
+import { filterDependenciesByType } from '@pnpm/pkg-manifest.utils';
+export function getWantedDependencies(pkg, opts) {
+    let depsToInstall = filterDependenciesByType(pkg, opts?.includeDirect ?? {
+        dependencies: true,
+        devDependencies: true,
+        optionalDependencies: true,
+    });
+    if (opts?.autoInstallPeers) {
+        depsToInstall = {
+            ...pkg.peerDependencies,
+            ...depsToInstall,
+        };
+    }
+    return getWantedDependenciesFromGivenSet(depsToInstall, {
+        dependencies: pkg.dependencies ?? {},
+        devDependencies: pkg.devDependencies ?? {},
+        optionalDependencies: pkg.optionalDependencies ?? {},
+        dependenciesMeta: pkg.dependenciesMeta ?? {},
+        peerDependencies: pkg.peerDependencies ?? {},
+    });
+}
+function getWantedDependenciesFromGivenSet(deps, opts) {
+    if (!deps)
+        return [];
+    return Object.entries(deps).map(([alias, bareSpecifier]) => {
+        let depType;
+        if (opts.optionalDependencies[alias] != null)
+            depType = 'optional';
+        else if (opts.dependencies[alias] != null)
+            depType = 'prod';
+        else if (opts.devDependencies[alias] != null)
+            depType = 'dev';
+        else if (opts.peerDependencies[alias] != null)
+            depType = 'prod';
+        return {
+            alias,
+            dev: depType === 'dev',
+            injected: opts.dependenciesMeta[alias]?.injected,
+            optional: depType === 'optional',
+            bareSpecifier,
+            prevSpecifier: bareSpecifier,
+        };
+    });
+}
+//# sourceMappingURL=getWantedDependencies.js.map

package/lib/hoistPeers.d.ts

@@ -0,0 +1,10 @@
+import type { PreferredVersions } from '@pnpm/resolving.resolver-base';
+import type { PkgAddressOrLink } from './resolveDependencies.js';
+export declare function hoistPeers(opts: {
+    autoInstallPeers: boolean;
+    allPreferredVersions?: PreferredVersions;
+    workspaceRootDeps: PkgAddressOrLink[];
+}, missingRequiredPeers: Array<[string, {
+    range: string;
+}]>): Record<string, string>;
+export declare function getHoistableOptionalPeers(allMissingOptionalPeers: Record<string, string[]>, allPreferredVersions: PreferredVersions): Record<string, string>;

package/lib/hoistPeers.js

@@ -0,0 +1,75 @@
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import semver from 'semver';
+export function hoistPeers(opts, missingRequiredPeers) {
+    const dependencies = {};
+    for (const [peerName, { range }] of missingRequiredPeers) {
+        const rootDepByAlias = opts.workspaceRootDeps.find((rootDep) => rootDep.alias === peerName);
+        if (rootDepByAlias?.normalizedBareSpecifier) {
+            dependencies[peerName] = rootDepByAlias.normalizedBareSpecifier;
+            continue;
+        }
+        const rootDep = opts.workspaceRootDeps
+            .filter((rootDep) => rootDep.pkg.name === peerName)
+            .sort((rootDep1, rootDep2) => lexCompare(rootDep1.alias, rootDep2.alias))[0];
+        if (rootDep?.normalizedBareSpecifier) {
+            dependencies[peerName] = rootDep.normalizedBareSpecifier;
+            continue;
+        }
+        if (opts.allPreferredVersions[peerName]) {
+            const versions = [];
+            const nonVersions = [];
+            for (const [spec, specType] of Object.entries(opts.allPreferredVersions[peerName])) {
+                if (specType === 'version') {
+                    versions.push(spec);
+                }
+                else {
+                    nonVersions.push(spec);
+                }
+            }
+            // When the range is an exact version (e.g. pinned by an override like "4.3.0"),
+            // try to find a preferred version that satisfies it. This prevents a stale
+            // higher version from the lockfile being picked over the overridden version.
+            // For regular semver ranges (e.g. "^1.0.0"), use the highest preferred
+            // version for deduplication.
+            const isExactVersion = semver.valid(range) != null;
+            const satisfyingVersion = isExactVersion
+                ? semver.maxSatisfying(versions, range, { includePrerelease: true })
+                : null;
+            if (satisfyingVersion) {
+                dependencies[peerName] = [satisfyingVersion, ...nonVersions].join(' || ');
+            }
+            else if (isExactVersion && opts.autoInstallPeers) {
+                // No preferred version satisfies the exact override version.
+                // Use the range directly so pnpm resolves it from the registry.
+                dependencies[peerName] = range;
+            }
+            else {
+                dependencies[peerName] = [semver.maxSatisfying(versions, '*', { includePrerelease: true }), ...nonVersions].join(' || ');
+            }
+        }
+        else if (opts.autoInstallPeers) {
+            dependencies[peerName] = range;
+        }
+    }
+    return dependencies;
+}
+export function getHoistableOptionalPeers(allMissingOptionalPeers, allPreferredVersions) {
+    const optionalDependencies = {};
+    for (const [missingOptionalPeerName, ranges] of Object.entries(allMissingOptionalPeers)) {
+        if (!allPreferredVersions[missingOptionalPeerName])
+            continue;
+        let maxSatisfyingVersion;
+        for (const [version, specType] of Object.entries(allPreferredVersions[missingOptionalPeerName])) {
+            if (specType === 'version' &&
+                ranges.every(range => semver.satisfies(version, range)) &&
+                (!maxSatisfyingVersion || semver.gt(version, maxSatisfyingVersion))) {
+                maxSatisfyingVersion = version;
+            }
+        }
+        if (maxSatisfyingVersion) {
+            optionalDependencies[missingOptionalPeerName] = maxSatisfyingVersion;
+        }
+    }
+    return optionalDependencies;
+}
+//# sourceMappingURL=hoistPeers.js.map

package/lib/index.d.ts

@@ -0,0 +1,53 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import { type DependenciesField, type PeerDependencyIssuesByProjects, type PinnedVersion, type ProjectManifest } from '@pnpm/types';
+import { getWantedDependencies, type WantedDependency } from './getWantedDependencies.js';
+import { type UpdateMatchingFunction } from './resolveDependencies.js';
+import { type Importer, type LinkedDependency, type ResolveDependenciesOptions, type ResolvedPackage } from './resolveDependencyTree.js';
+import { type DependenciesByProjectId, type GenericDependenciesGraphNodeWithResolvedChildren, type GenericDependenciesGraphWithResolvedChildren } from './resolvePeers.js';
+export type DependenciesGraph = GenericDependenciesGraphWithResolvedChildren<ResolvedPackage>;
+export type DependenciesGraphNode = GenericDependenciesGraphNodeWithResolvedChildren & ResolvedPackage;
+export { getWantedDependencies, type LinkedDependency, type PinnedVersion, type ResolvedPackage, type UpdateMatchingFunction, type WantedDependency, };
+export interface ImporterToResolve extends Importer<{
+    isNew?: boolean;
+    nodeExecPath?: string;
+    pinnedVersion?: PinnedVersion;
+    updateSpec?: boolean;
+    preserveNonSemverVersionSpec?: boolean;
+}> {
+    peer?: boolean;
+    pinnedVersion?: PinnedVersion;
+    binsDir: string;
+    manifest: ProjectManifest;
+    originalManifest?: ProjectManifest;
+    update?: boolean;
+    updateMatching?: UpdateMatchingFunction;
+    updatePackageManifest: boolean;
+    targetDependenciesField?: DependenciesField;
+}
+export interface ResolveDependenciesResult {
+    dependenciesByProjectId: DependenciesByProjectId;
+    dependenciesGraph: GenericDependenciesGraphWithResolvedChildren<ResolvedPackage>;
+    updatedCatalogs?: Catalogs | undefined;
+    outdatedDependencies: {
+        [pkgId: string]: string;
+    };
+    linkedDependenciesByProjectId: Record<string, LinkedDependency[]>;
+    newLockfile: LockfileObject;
+    peerDependencyIssuesByProjects: PeerDependencyIssuesByProjects;
+    waitTillAllFetchingsFinish: () => Promise<void>;
+    wantedToBeSkippedPackageIds: Set<string>;
+}
+export declare function resolveDependencies(importers: ImporterToResolve[], opts: ResolveDependenciesOptions & {
+    defaultUpdateDepth: number;
+    dedupePeerDependents?: boolean;
+    dedupeDirectDeps?: boolean;
+    dedupeInjectedDeps?: boolean;
+    excludeLinksFromLockfile?: boolean;
+    preserveWorkspaceProtocol: boolean;
+    saveWorkspaceProtocol: 'rolling' | boolean;
+    lockfileIncludeTarballUrl?: boolean;
+    allowUnusedPatches?: boolean;
+    enableGlobalVirtualStore?: boolean;
+    allProjectIds: string[];
+}): Promise<ResolveDependenciesResult>;