@pnpm/installing.deps-installer 1012.0.1

package/lib/install/extendInstallOptions.d.ts

@@ -0,0 +1,163 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import { type VersionOverride } from '@pnpm/config.parse-overrides';
+import type { CustomFetcher, CustomResolver, PreResolutionHookContext } from '@pnpm/hooks.types';
+import type { ProjectOptions } from '@pnpm/installing.context';
+import type { HoistingLimits } from '@pnpm/installing.deps-restorer';
+import type { IncludedDependencies } from '@pnpm/installing.modules-yaml';
+import type { LockfileObject } from '@pnpm/lockfile.fs';
+import type { WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { StoreController } from '@pnpm/store.controller-types';
+import type { AllowedDeprecatedVersions, PackageExtension, PackageVulnerabilityAudit, PeerDependencyRules, ReadPackageHook, Registries, SupportedArchitectures, TrustPolicy } from '@pnpm/types';
+import type { ReporterFunction } from '../types.js';
+export interface StrictInstallOptions {
+    autoConfirmAllPrompts: boolean;
+    autoInstallPeers: boolean;
+    autoInstallPeersFromHighestMatch: boolean;
+    catalogs: Catalogs;
+    catalogMode: 'strict' | 'prefer' | 'manual';
+    cleanupUnusedCatalogs: boolean;
+    frozenLockfile: boolean;
+    frozenLockfileIfExists: boolean;
+    enableGlobalVirtualStore: boolean;
+    enablePnp: boolean;
+    extraBinPaths: string[];
+    extraEnv: Record<string, string>;
+    hoistingLimits?: HoistingLimits;
+    externalDependencies?: Set<string>;
+    useLockfile: boolean;
+    saveLockfile: boolean;
+    useGitBranchLockfile: boolean;
+    mergeGitBranchLockfiles: boolean;
+    linkWorkspacePackagesDepth: number;
+    lockfileOnly: boolean;
+    forceFullResolution: boolean;
+    fixLockfile: boolean;
+    dedupe: boolean;
+    ignoreCompatibilityDb: boolean;
+    ignoreDepScripts: boolean;
+    ignorePackageManifest: boolean;
+    /**
+     * When true, skip fetching local dependencies (file: protocol pointing to directories).
+     * This is used by `pnpm fetch` which only downloads packages from the registry
+     * and doesn't need local packages that won't be available (e.g., in Docker builds).
+     */
+    ignoreLocalPackages: boolean;
+    preferFrozenLockfile: boolean;
+    saveWorkspaceProtocol: boolean | 'rolling';
+    lockfileCheck?: (prev: LockfileObject, next: LockfileObject) => void;
+    lockfileIncludeTarballUrl?: boolean;
+    preferWorkspacePackages: boolean;
+    preserveWorkspaceProtocol: boolean;
+    saveCatalogName?: string;
+    scriptsPrependNodePath: boolean | 'warn-only';
+    scriptShell?: string;
+    shellEmulator: boolean;
+    storeController: StoreController;
+    storeDir: string;
+    reporter: ReporterFunction;
+    force: boolean;
+    forcePublicHoistPattern: boolean;
+    depth: number;
+    lockfileDir: string;
+    modulesDir: string;
+    rawConfig: Record<string, any>;
+    verifyStoreIntegrity: boolean;
+    engineStrict: boolean;
+    allowBuilds?: Record<string, boolean | string>;
+    nodeLinker: 'isolated' | 'hoisted' | 'pnp';
+    nodeVersion?: string;
+    packageExtensions: Record<string, PackageExtension>;
+    ignoredOptionalDependencies: string[];
+    pnpmfile: string[] | string;
+    ignorePnpmfile: boolean;
+    packageManager: {
+        name: string;
+        version: string;
+    };
+    pruneLockfileImporters: boolean;
+    hooks: {
+        readPackage?: ReadPackageHook[];
+        preResolution?: Array<(ctx: PreResolutionHookContext) => Promise<void>>;
+        afterAllResolved?: Array<(lockfile: LockfileObject) => LockfileObject | Promise<LockfileObject>>;
+        customResolvers?: CustomResolver[];
+        customFetchers?: CustomFetcher[];
+        calculatePnpmfileChecksum?: () => Promise<string | undefined>;
+    };
+    sideEffectsCacheRead: boolean;
+    sideEffectsCacheWrite: boolean;
+    strictPeerDependencies: boolean;
+    include: IncludedDependencies;
+    includeDirect: IncludedDependencies;
+    ignoreCurrentSpecifiers: boolean;
+    ignoreScripts: boolean;
+    childConcurrency: number;
+    userAgent: string;
+    unsafePerm: boolean;
+    registries: Registries;
+    tag: string;
+    overrides: Record<string, string>;
+    ownLifecycleHooksStdio: 'inherit' | 'pipe';
+    workspacePackages?: WorkspacePackages;
+    pruneStore: boolean;
+    virtualStoreDir?: string;
+    globalVirtualStoreDir: string;
+    dir: string;
+    symlink: boolean;
+    enableModulesDir: boolean;
+    virtualStoreOnly: boolean;
+    modulesCacheMaxAge: number;
+    peerDependencyRules: PeerDependencyRules;
+    allowedDeprecatedVersions: AllowedDeprecatedVersions;
+    allowUnusedPatches: boolean;
+    preferSymlinkedExecutables: boolean;
+    resolutionMode: 'highest' | 'time-based' | 'lowest-direct';
+    resolvePeersFromWorkspaceRoot: boolean;
+    ignoreWorkspaceCycles: boolean;
+    disallowWorkspaceCycles: boolean;
+    publicHoistPattern: string[] | undefined;
+    hoistPattern: string[] | undefined;
+    forceHoistPattern: boolean;
+    shamefullyHoist: boolean;
+    forceShamefullyHoist: boolean;
+    global: boolean;
+    globalBin?: string;
+    patchedDependencies?: Record<string, string>;
+    allProjects: ProjectOptions[];
+    resolveSymlinksInInjectedDirs: boolean;
+    dedupeDirectDeps: boolean;
+    dedupeInjectedDeps: boolean;
+    dedupePeerDependents: boolean;
+    extendNodePath: boolean;
+    excludeLinksFromLockfile: boolean;
+    confirmModulesPurge: boolean;
+    /**
+     * Don't relink local directory dependencies if they are not hard linked from the local directory.
+     *
+     * This option was added to fix an issue with Bit CLI.
+     * Bit compile adds dist directories to the injected dependencies, so if pnpm were to relink them,
+     * the dist directories would be deleted.
+     *
+     * The option might be used in the future to improve performance.
+     */
+    disableRelinkLocalDirDeps: boolean;
+    supportedArchitectures?: SupportedArchitectures;
+    hoistWorkspacePackages?: boolean;
+    virtualStoreDirMaxLength: number;
+    peersSuffixMaxLength: number;
+    returnListOfDepsRequiringBuild?: boolean;
+    injectWorkspacePackages?: boolean;
+    ci?: boolean;
+    minimumReleaseAge?: number;
+    minimumReleaseAgeExclude?: string[];
+    trustPolicy?: TrustPolicy;
+    trustPolicyExclude?: string[];
+    trustPolicyIgnoreAfter?: number;
+    packageVulnerabilityAudit?: PackageVulnerabilityAudit;
+    blockExoticSubdeps?: boolean;
+}
+export type InstallOptions = Partial<StrictInstallOptions> & Pick<StrictInstallOptions, 'storeDir' | 'storeController'>;
+export interface ProcessedInstallOptions extends StrictInstallOptions {
+    readPackageHook?: ReadPackageHook;
+    parsedOverrides: VersionOverride[];
+}
+export declare function extendOptions(opts: InstallOptions): ProcessedInstallOptions;

package/lib/install/extendInstallOptions.js

@@ -0,0 +1,156 @@
+import path from 'node:path';
+import { DEFAULT_REGISTRIES, normalizeRegistries } from '@pnpm/config.normalize-registries';
+import { parseOverrides } from '@pnpm/config.parse-overrides';
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { PnpmError } from '@pnpm/error';
+import { createReadPackageHook } from '@pnpm/hooks.read-package-hook';
+import { pnpmPkgJson } from '../pnpmPkgJson.js';
+const defaults = (opts) => {
+    const packageManager = opts.packageManager ?? {
+        name: pnpmPkgJson.name,
+        version: pnpmPkgJson.version,
+    };
+    return {
+        allowedDeprecatedVersions: {},
+        allowUnusedPatches: false,
+        autoConfirmAllPrompts: opts.autoConfirmAllPrompts ?? false,
+        autoInstallPeers: true,
+        autoInstallPeersFromHighestMatch: false,
+        catalogs: {},
+        childConcurrency: 5,
+        confirmModulesPurge: !(opts.autoConfirmAllPrompts || opts.force),
+        depth: 0,
+        dedupeInjectedDeps: true,
+        enableGlobalVirtualStore: false,
+        enablePnp: false,
+        engineStrict: false,
+        force: false,
+        forceFullResolution: false,
+        frozenLockfile: false,
+        hoistPattern: undefined,
+        publicHoistPattern: undefined,
+        hooks: {},
+        ignoreCurrentSpecifiers: false,
+        ignoreDepScripts: false,
+        ignoreScripts: false,
+        include: {
+            dependencies: true,
+            devDependencies: true,
+            optionalDependencies: true,
+        },
+        includeDirect: {
+            dependencies: true,
+            devDependencies: true,
+            optionalDependencies: true,
+        },
+        lockfileDir: opts.lockfileDir ?? opts.dir ?? process.cwd(),
+        lockfileOnly: false,
+        nodeVersion: opts.nodeVersion,
+        nodeLinker: 'isolated',
+        overrides: {},
+        ownLifecycleHooksStdio: 'inherit',
+        ignoreCompatibilityDb: false,
+        ignorePackageManifest: false,
+        ignoreLocalPackages: false,
+        packageExtensions: {},
+        ignoredOptionalDependencies: [],
+        packageManager,
+        preferFrozenLockfile: true,
+        preferWorkspacePackages: false,
+        preserveWorkspaceProtocol: true,
+        pruneLockfileImporters: false,
+        pruneStore: false,
+        rawConfig: {},
+        registries: DEFAULT_REGISTRIES,
+        resolutionMode: 'lowest-direct',
+        saveWorkspaceProtocol: 'rolling',
+        scriptsPrependNodePath: false,
+        shamefullyHoist: false,
+        shellEmulator: false,
+        sideEffectsCacheRead: false,
+        sideEffectsCacheWrite: false,
+        symlink: true,
+        storeController: opts.storeController,
+        storeDir: opts.storeDir,
+        strictPeerDependencies: false,
+        tag: 'latest',
+        unsafePerm: process.platform === 'win32' ||
+            process.platform === 'cygwin' ||
+            !process.setgid ||
+            process.getuid?.() !== 0,
+        catalogMode: 'manual',
+        cleanupUnusedCatalogs: false,
+        useLockfile: true,
+        saveLockfile: true,
+        useGitBranchLockfile: false,
+        mergeGitBranchLockfiles: false,
+        userAgent: `${packageManager.name}/${packageManager.version} npm/? node/${process.version} ${process.platform} ${process.arch}`,
+        verifyStoreIntegrity: true,
+        enableModulesDir: true,
+        virtualStoreOnly: false,
+        modulesCacheMaxAge: 7 * 24 * 60,
+        resolveSymlinksInInjectedDirs: false,
+        dedupeDirectDeps: true,
+        dedupePeerDependents: true,
+        resolvePeersFromWorkspaceRoot: true,
+        extendNodePath: true,
+        ignoreWorkspaceCycles: false,
+        disallowWorkspaceCycles: false,
+        excludeLinksFromLockfile: false,
+        virtualStoreDirMaxLength: 120,
+        peersSuffixMaxLength: 1000,
+        blockExoticSubdeps: false,
+    };
+};
+export function extendOptions(opts) {
+    if (opts) {
+        for (const key in opts) {
+            if (opts[key] === undefined) {
+                delete opts[key];
+            }
+        }
+    }
+    const defaultOpts = defaults(opts);
+    const extendedOpts = {
+        ...defaultOpts,
+        ...opts,
+        storeDir: defaultOpts.storeDir,
+        parsedOverrides: parseOverrides(opts.overrides ?? {}, opts.catalogs ?? {}),
+    };
+    extendedOpts.readPackageHook = createReadPackageHook({
+        ignoreCompatibilityDb: extendedOpts.ignoreCompatibilityDb,
+        readPackageHook: extendedOpts.hooks?.readPackage,
+        overrides: extendedOpts.parsedOverrides,
+        lockfileDir: extendedOpts.lockfileDir,
+        packageExtensions: extendedOpts.packageExtensions,
+        ignoredOptionalDependencies: extendedOpts.ignoredOptionalDependencies,
+    });
+    if (extendedOpts.virtualStoreOnly && !extendedOpts.enableModulesDir && !extendedOpts.enableGlobalVirtualStore) {
+        throw new PnpmError('CONFIG_CONFLICT_VIRTUAL_STORE_ONLY_WITH_NO_MODULES_DIR', 'Cannot use virtualStoreOnly when enableModulesDir is false (the standard virtual store requires node_modules/.pnpm)');
+    }
+    if (extendedOpts.virtualStoreOnly) {
+        // Ensure .modules.yaml records empty hoist patterns so a subsequent
+        // normal install knows hoisting must be redone from scratch.
+        extendedOpts.hoistPattern = [];
+        extendedOpts.publicHoistPattern = [];
+    }
+    if (extendedOpts.lockfileOnly) {
+        extendedOpts.ignoreScripts = true;
+        if (!extendedOpts.useLockfile) {
+            throw new PnpmError('CONFIG_CONFLICT_LOCKFILE_ONLY_WITH_NO_LOCKFILE', `Cannot generate a ${WANTED_LOCKFILE} because lockfile is set to false`);
+        }
+    }
+    if (extendedOpts.userAgent.startsWith('npm/')) {
+        extendedOpts.userAgent = `${extendedOpts.packageManager.name}/${extendedOpts.packageManager.version} ${extendedOpts.userAgent}`;
+    }
+    extendedOpts.registries = normalizeRegistries(extendedOpts.registries);
+    extendedOpts.rawConfig['registry'] = extendedOpts.registries.default;
+    if (extendedOpts.enableGlobalVirtualStore && extendedOpts.virtualStoreDir == null) {
+        extendedOpts.virtualStoreDir = path.join(extendedOpts.storeDir, 'links');
+    }
+    extendedOpts.globalVirtualStoreDir = extendedOpts.enableGlobalVirtualStore
+        ? extendedOpts.virtualStoreDir
+        : path.join(extendedOpts.storeDir, 'links');
+    return extendedOpts;
+}
+//# sourceMappingURL=extendInstallOptions.js.map

package/lib/install/index.d.ts

@@ -0,0 +1,110 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import { PnpmError } from '@pnpm/error';
+import { type PinnedVersion, type UpdateMatchingFunction, type WantedDependency } from '@pnpm/installing.deps-resolver';
+import { type InstallationResultStats } from '@pnpm/installing.deps-restorer';
+import type { PreferredVersions } from '@pnpm/resolving.resolver-base';
+import type { DependenciesField, DepPath, IgnoredBuilds, PeerDependencyIssues, ProjectId, ProjectManifest, ProjectRootDir, ReadPackageHook } from '@pnpm/types';
+import { type InstallOptions } from './extendInstallOptions.js';
+interface InstallMutationOptions {
+    update?: boolean;
+    updateToLatest?: boolean;
+    updateMatching?: UpdateMatchingFunction;
+    updatePackageManifest?: boolean;
+}
+export interface InstallDepsMutation extends InstallMutationOptions {
+    mutation: 'install';
+    pruneDirectDependencies?: boolean;
+}
+export interface InstallSomeDepsMutation extends InstallMutationOptions {
+    allowNew?: boolean;
+    dependencySelectors: string[];
+    mutation: 'installSome';
+    peer?: boolean;
+    pruneDirectDependencies?: boolean;
+    pinnedVersion?: PinnedVersion;
+    targetDependenciesField?: DependenciesField;
+}
+export interface UninstallSomeDepsMutation {
+    mutation: 'uninstallSome';
+    dependencyNames: string[];
+    targetDependenciesField?: DependenciesField;
+}
+export type DependenciesMutation = InstallDepsMutation | InstallSomeDepsMutation | UninstallSomeDepsMutation;
+type Opts = Omit<InstallOptions, 'allProjects'> & {
+    preferredVersions?: PreferredVersions;
+    pruneDirectDependencies?: boolean;
+    binsDir?: string;
+} & InstallMutationOptions;
+export interface InstallResult {
+    /**
+     * A partial of new or updated catalog config entries. A change will be
+     * produced if a dependency using the catalog protocol was newly added or
+     * updated during this install. To obtain the full catalog, callers should
+     * merge this object with the current catalog configs in pnpm-workspace.yaml.
+     */
+    updatedCatalogs: Catalogs | undefined;
+    updatedManifest: ProjectManifest;
+    ignoredBuilds: IgnoredBuilds | undefined;
+}
+export declare function install(manifest: ProjectManifest, opts: Opts): Promise<InstallResult>;
+export type MutatedProject = DependenciesMutation & {
+    rootDir: ProjectRootDir;
+};
+export type MutateModulesOptions = InstallOptions & {
+    preferredVersions?: PreferredVersions;
+    hooks?: {
+        readPackage?: ReadPackageHook[] | ReadPackageHook;
+    } | InstallOptions['hooks'];
+};
+export interface MutateModulesInSingleProjectResult {
+    updatedCatalogs: Catalogs | undefined;
+    updatedProject: UpdatedProject;
+    ignoredBuilds: IgnoredBuilds | undefined;
+}
+export declare function mutateModulesInSingleProject(project: MutatedProject & {
+    binsDir?: string;
+    manifest: ProjectManifest;
+    rootDir: ProjectRootDir;
+    modulesDir?: string;
+}, maybeOpts: Omit<MutateModulesOptions, 'allProjects'> & InstallMutationOptions): Promise<MutateModulesInSingleProjectResult>;
+export interface MutateModulesResult {
+    updatedCatalogs?: Catalogs;
+    updatedProjects: UpdatedProject[];
+    stats: InstallationResultStats;
+    depsRequiringBuild?: DepPath[];
+    ignoredBuilds: IgnoredBuilds | undefined;
+}
+export declare function mutateModules(projects: MutatedProject[], maybeOpts: MutateModulesOptions): Promise<MutateModulesResult>;
+export declare function addDependenciesToPackage(manifest: ProjectManifest, dependencySelectors: string[], opts: Omit<InstallOptions, 'allProjects'> & {
+    bin?: string;
+    allowNew?: boolean;
+    peer?: boolean;
+    pinnedVersion?: 'major' | 'minor' | 'patch';
+    targetDependenciesField?: DependenciesField;
+} & InstallMutationOptions): Promise<InstallResult>;
+export type ImporterToUpdate = {
+    buildIndex: number;
+    binsDir: string;
+    id: ProjectId;
+    manifest: ProjectManifest;
+    originalManifest?: ProjectManifest;
+    modulesDir: string;
+    rootDir: ProjectRootDir;
+    pruneDirectDependencies: boolean;
+    removePackages?: string[];
+    updatePackageManifest: boolean;
+    wantedDependencies: Array<WantedDependency & {
+        isNew?: boolean;
+        updateSpec?: boolean;
+    }>;
+} & DependenciesMutation;
+export interface UpdatedProject {
+    originalManifest?: ProjectManifest;
+    manifest: ProjectManifest;
+    peerDependencyIssues?: PeerDependencyIssues;
+    rootDir: ProjectRootDir;
+}
+export declare class IgnoredBuildsError extends PnpmError {
+    constructor(ignoredBuilds: IgnoredBuilds);
+}
+export {};