@pnpm/installing.commands 1004.6.10

package/lib/import/index.js

@@ -0,0 +1,238 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { docsUrl } from '@pnpm/cli.utils';
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { PnpmError } from '@pnpm/error';
+import gfs from '@pnpm/fs.graceful-fs';
+import { install } from '@pnpm/installing.deps-installer';
+import { logger } from '@pnpm/logger';
+import { createStoreController, } from '@pnpm/store.connection-manager';
+import { readProjectManifestOnly } from '@pnpm/workspace.project-manifest-reader';
+import { findWorkspaceProjects } from '@pnpm/workspace.projects-reader';
+import { sequenceGraph } from '@pnpm/workspace.projects-sorter';
+import * as structUtils from '@yarnpkg/core/structUtils';
+import yarnLockfileLib from '@yarnpkg/lockfile';
+import { parseSyml } from '@yarnpkg/parsers';
+import { rimraf } from '@zkochan/rimraf';
+import { loadJsonFile } from 'load-json-file';
+import { map as mapValues } from 'ramda';
+import { renderHelp } from 'render-help';
+import { recursive } from '../recursive.js';
+import { yarnLockFileKeyNormalizer } from './yarnUtil.js';
+const YarnLockType = {
+    yarn: 'yarn',
+    yarn2: 'yarn2',
+};
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return {};
+}
+export function help() {
+    return renderHelp({
+        description: `Generates ${WANTED_LOCKFILE} from an npm package-lock.json (or npm-shrinkwrap.json, yarn.lock) file.`,
+        url: docsUrl('import'),
+        usages: [
+            'pnpm import',
+        ],
+    });
+}
+export const commandNames = ['import'];
+export async function handler(opts, params) {
+    // Removing existing pnpm lockfile
+    // it should not influence the new one
+    await rimraf(path.join(opts.dir, WANTED_LOCKFILE));
+    const versionsByPackageNames = {};
+    let preferredVersions = {};
+    if (fs.existsSync(path.join(opts.dir, 'yarn.lock'))) {
+        const yarnPackageLockFile = await readYarnLockFile(opts.dir);
+        getAllVersionsFromYarnLockFile(yarnPackageLockFile, versionsByPackageNames);
+    }
+    else if (fs.existsSync(path.join(opts.dir, 'package-lock.json')) ||
+        fs.existsSync(path.join(opts.dir, 'npm-shrinkwrap.json'))) {
+        const npmPackageLock = await readNpmLockfile(opts.dir);
+        if (npmPackageLock.lockfileVersion < 3) {
+            getAllVersionsByPackageNamesPreV3(npmPackageLock, versionsByPackageNames);
+        }
+        else {
+            getAllVersionsByPackageNames(npmPackageLock, versionsByPackageNames);
+        }
+    }
+    else {
+        throw new PnpmError('LOCKFILE_NOT_FOUND', 'No lockfile found');
+    }
+    preferredVersions = getPreferredVersions(versionsByPackageNames);
+    // For a workspace with shared lockfile
+    if (opts.workspaceDir) {
+        const allProjects = opts.allProjects ?? await findWorkspaceProjects(opts.workspaceDir, {
+            ...opts,
+            patterns: opts.workspacePackagePatterns,
+        });
+        const selectedProjectsGraph = opts.selectedProjectsGraph ?? selectProjectByDir(allProjects, opts.dir);
+        if (selectedProjectsGraph != null) {
+            const sequencedGraph = sequenceGraph(selectedProjectsGraph);
+            // Check and warn if there are cyclic dependencies
+            if (!opts.ignoreWorkspaceCycles && !sequencedGraph.safe) {
+                const cyclicDependenciesInfo = sequencedGraph.cycles.length > 0
+                    ? `: ${sequencedGraph.cycles.map(deps => deps.join(', ')).join('; ')}`
+                    : '';
+                if (opts.disallowWorkspaceCycles) {
+                    throw new PnpmError('DISALLOW_WORKSPACE_CYCLES', `There are cyclic workspace dependencies${cyclicDependenciesInfo}`);
+                }
+                logger.warn({
+                    message: `There are cyclic workspace dependencies${cyclicDependenciesInfo}`,
+                    prefix: opts.workspaceDir,
+                });
+            }
+            await recursive(allProjects, params, 
+            // @ts-expect-error
+            {
+                ...opts,
+                lockfileOnly: true,
+                selectedProjectsGraph,
+                preferredVersions,
+                workspaceDir: opts.workspaceDir,
+            }, 'import');
+        }
+        return;
+    }
+    const store = await createStoreController(opts);
+    const manifest = await readProjectManifestOnly(opts.dir);
+    const installOpts = {
+        ...opts,
+        lockfileOnly: true,
+        preferredVersions,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+    };
+    await install(manifest, installOpts);
+}
+async function readYarnLockFile(dir) {
+    try {
+        const yarnLockFile = await gfs.readFile(path.join(dir, 'yarn.lock'), 'utf8');
+        const yarnLockFileType = getYarnLockfileType(yarnLockFile);
+        if (yarnLockFileType === YarnLockType.yarn) {
+            const lockJsonFile = yarnLockfileLib.parse(yarnLockFile);
+            if (lockJsonFile.type === 'success') {
+                return lockJsonFile.object;
+            }
+            else {
+                throw new PnpmError('YARN_LOCKFILE_PARSE_FAILED', `Yarn.lock file was ${lockJsonFile.type}`);
+            }
+        }
+        else if (yarnLockFileType === YarnLockType.yarn2) {
+            const lockJsonFile = parseYarn2Lock(yarnLockFile);
+            if (lockJsonFile.type === YarnLockType.yarn2) {
+                return lockJsonFile.object;
+            }
+        }
+    }
+    catch (err) { // eslint-disable-line
+        if (err['code'] !== 'ENOENT')
+            throw err;
+    }
+    throw new PnpmError('YARN_LOCKFILE_NOT_FOUND', 'No yarn.lock found');
+}
+function parseYarn2Lock(lockFileContents) {
+    const parseYarnLock = parseSyml(lockFileContents);
+    delete parseYarnLock.__metadata;
+    const dependencies = {};
+    const { parseDescriptor, parseRange } = structUtils;
+    const keyNormalizer = yarnLockFileKeyNormalizer(parseDescriptor, parseRange);
+    for (const fullDescriptor in parseYarnLock) {
+        const versionData = parseYarnLock[fullDescriptor];
+        for (const descriptor of keyNormalizer(fullDescriptor)) {
+            dependencies[descriptor] = versionData;
+        }
+    }
+    return {
+        object: dependencies,
+        type: YarnLockType.yarn2,
+    };
+}
+async function readNpmLockfile(dir) {
+    try {
+        return await loadJsonFile(path.join(dir, 'package-lock.json'));
+    }
+    catch (err) { // eslint-disable-line
+        if (err['code'] !== 'ENOENT')
+            throw err;
+    }
+    try {
+        return await loadJsonFile(path.join(dir, 'npm-shrinkwrap.json'));
+    }
+    catch (err) { // eslint-disable-line
+        if (err['code'] !== 'ENOENT')
+            throw err;
+    }
+    throw new PnpmError('NPM_LOCKFILE_NOT_FOUND', 'No package-lock.json or npm-shrinkwrap.json found');
+}
+function getPreferredVersions(versionsByPackageNames) {
+    const preferredVersions = mapValues((versions) => Object.fromEntries(Array.from(versions).map((version) => [version, 'version'])), versionsByPackageNames);
+    return preferredVersions;
+}
+function getAllVersionsByPackageNamesPreV3(npmPackageLock, versionsByPackageNames) {
+    if (npmPackageLock.dependencies == null)
+        return;
+    for (const [packageName, { version }] of Object.entries(npmPackageLock.dependencies)) {
+        if (!versionsByPackageNames[packageName]) {
+            versionsByPackageNames[packageName] = new Set();
+        }
+        versionsByPackageNames[packageName].add(version);
+    }
+    for (const dep of Object.values(npmPackageLock.dependencies)) {
+        getAllVersionsByPackageNamesPreV3(dep, versionsByPackageNames);
+    }
+}
+function getAllVersionsByPackageNames(pkg, versionsByPackageNames) {
+    if (pkg.dependencies) {
+        extractDependencies(versionsByPackageNames, pkg.dependencies);
+    }
+    if ('packages' in pkg && pkg.packages) {
+        extractDependencies(versionsByPackageNames, pkg.packages);
+    }
+}
+function extractDependencies(versionsByPackageNames, dependencies) {
+    for (let [pkgName, pkgDetails] of Object.entries(dependencies)) {
+        if (pkgName.includes('node_modules')) {
+            pkgName = pkgName.substring(pkgName.lastIndexOf('node_modules/') + 13);
+        }
+        if (!versionsByPackageNames[pkgName]) {
+            versionsByPackageNames[pkgName] = new Set();
+        }
+        if (pkgDetails.version) {
+            versionsByPackageNames[pkgName].add(pkgDetails.version);
+        }
+        if (pkgDetails.packages) {
+            extractDependencies(versionsByPackageNames, pkgDetails.packages);
+        }
+        if (pkgDetails.dependencies) {
+            for (const [pkgName1, version] of Object.entries(pkgDetails.dependencies)) {
+                if (!versionsByPackageNames[pkgName1]) {
+                    versionsByPackageNames[pkgName1] = new Set();
+                }
+                versionsByPackageNames[pkgName1].add(version);
+            }
+        }
+    }
+}
+function getAllVersionsFromYarnLockFile(yarnPackageLock, versionsByPackageNames) {
+    for (const [packageName, { version }] of Object.entries(yarnPackageLock)) {
+        const pkgName = packageName.substring(0, packageName.lastIndexOf('@'));
+        if (!versionsByPackageNames[pkgName]) {
+            versionsByPackageNames[pkgName] = new Set();
+        }
+        versionsByPackageNames[pkgName].add(version);
+    }
+}
+function selectProjectByDir(projects, searchedDir) {
+    const project = projects.find(({ rootDir }) => path.relative(rootDir, searchedDir) === '');
+    if (project == null)
+        return undefined;
+    return { [searchedDir]: { dependencies: [], package: project } };
+}
+function getYarnLockfileType(lockFileContents) {
+    return lockFileContents.includes('__metadata')
+        ? YarnLockType.yarn2
+        : YarnLockType.yarn;
+}
+//# sourceMappingURL=index.js.map

package/lib/import/yarnUtil.d.ts

@@ -0,0 +1,8 @@
+/**
+ * https://github.com/snyk/nodejs-lockfile-parser/blob/master/lib/parsers/yarn-utils.ts
+ */
+import type { structUtils } from '@yarnpkg/core';
+export type ParseDescriptor = typeof structUtils.parseDescriptor;
+export type ParseRange = typeof structUtils.parseRange;
+export type YarnLockFileKeyNormalizer = (fullDescriptor: string) => Set<string>;
+export declare const yarnLockFileKeyNormalizer: (parseDescriptor: typeof structUtils.parseDescriptor, parseRange: typeof structUtils.parseRange) => YarnLockFileKeyNormalizer;

package/lib/import/yarnUtil.js

@@ -0,0 +1,65 @@
+const BUILTIN_PLACEHOLDER = 'builtin';
+const MULTIPLE_KEYS_REGEXP = / *, */;
+const keyNormalizer = (parseDescriptor, parseRange) => (rawDescriptor) => {
+    // See https://yarnpkg.com/features/protocols
+    const descriptors = [rawDescriptor];
+    const descriptor = parseDescriptor(rawDescriptor);
+    const name = `${descriptor.scope ? '@' + descriptor.scope + '/' : ''}${descriptor.name}`;
+    const range = parseRange(descriptor.range);
+    const protocol = range.protocol;
+    switch (protocol) {
+        case 'npm:':
+        case 'file:':
+            descriptors.push(`${name}@${range.selector}`);
+            descriptors.push(`${name}@${protocol}${range.selector}`);
+            break;
+        case 'git:':
+        case 'git+ssh:':
+        case 'git+http:':
+        case 'git+https:':
+        case 'github:':
+            if (range.source) {
+                descriptors.push(`${name}@${protocol}${range.source}${range.selector ? '#' + range.selector : ''}`);
+            }
+            else {
+                descriptors.push(`${name}@${protocol}${range.selector}`);
+            }
+            break;
+        case 'patch:':
+            if (range.source && range.selector.startsWith(BUILTIN_PLACEHOLDER)) {
+                descriptors.push(range.source);
+            }
+            else {
+                descriptors.push(`${name}@${protocol}${range.source}${range.selector ? '#' + range.selector : ''}`);
+            }
+            break;
+        case null:
+        case undefined:
+            if (range.source) {
+                descriptors.push(`${name}@${range.source}#${range.selector}`);
+            }
+            else {
+                descriptors.push(`${name}@${range.selector}`);
+            }
+            break;
+        case 'http:':
+        case 'https:':
+        case 'link:':
+        case 'portal:':
+        case 'exec:':
+        case 'workspace:':
+        case 'virtual:':
+        default:
+            // For user defined plugins
+            descriptors.push(`${name}@${protocol}${range.selector}`);
+            break;
+    }
+    return descriptors;
+};
+export const yarnLockFileKeyNormalizer = (parseDescriptor, parseRange) => (fullDescriptor) => {
+    const allKeys = fullDescriptor
+        .split(MULTIPLE_KEYS_REGEXP)
+        .map(keyNormalizer(parseDescriptor, parseRange));
+    return new Set(allKeys.flat(5));
+};
+//# sourceMappingURL=yarnUtil.js.map

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+import * as add from './add.js';
+import * as ci from './ci.js';
+import * as dedupe from './dedupe.js';
+import * as fetch from './fetch.js';
+import * as importCommand from './import/index.js';
+import type { InstallCommandOptions } from './install.js';
+import * as install from './install.js';
+import * as link from './link.js';
+import * as prune from './prune.js';
+import * as remove from './remove.js';
+import * as unlink from './unlink.js';
+import * as update from './update/index.js';
+export { add, ci, dedupe, fetch, importCommand, install, type InstallCommandOptions, link, prune, remove, unlink, update };

package/lib/index.js

@@ -0,0 +1,13 @@
+import * as add from './add.js';
+import * as ci from './ci.js';
+import * as dedupe from './dedupe.js';
+import * as fetch from './fetch.js';
+import * as importCommand from './import/index.js';
+import * as install from './install.js';
+import * as link from './link.js';
+import * as prune from './prune.js';
+import * as remove from './remove.js';
+import * as unlink from './unlink.js';
+import * as update from './update/index.js';
+export { add, ci, dedupe, fetch, importCommand, install, link, prune, remove, unlink, update };
+//# sourceMappingURL=index.js.map

package/lib/install.d.ts

@@ -0,0 +1,28 @@
+import { type Config } from '@pnpm/config.reader';
+import type { CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const shorthands: Record<string, string>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export type InstallCommandOptions = Pick<Config, 'allProjects' | 'autoInstallPeers' | 'bail' | 'bin' | 'catalogs' | 'cliOptions' | 'configDependencies' | 'dedupeInjectedDeps' | 'dedupeDirectDeps' | 'dedupePeerDependents' | 'deployAllFiles' | 'depth' | 'dev' | 'enableGlobalVirtualStore' | 'engineStrict' | 'excludeLinksFromLockfile' | 'frozenLockfile' | 'global' | 'globalPnpmfile' | 'hooks' | 'ignorePnpmfile' | 'ignoreScripts' | 'injectWorkspacePackages' | 'linkWorkspacePackages' | 'rawLocalConfig' | 'lockfileDir' | 'lockfileOnly' | 'modulesDir' | 'nodeLinker' | 'patchedDependencies' | 'preferFrozenLockfile' | 'preferWorkspacePackages' | 'production' | 'registries' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'save' | 'saveDev' | 'saveExact' | 'saveOptional' | 'savePeer' | 'savePrefix' | 'saveProd' | 'saveCatalogName' | 'saveWorkspaceProtocol' | 'lockfileIncludeTarballUrl' | 'allProjectsGraph' | 'selectedProjectsGraph' | 'sideEffectsCache' | 'sideEffectsCacheReadonly' | 'sort' | 'sharedWorkspaceLockfile' | 'tag' | 'allowBuilds' | 'optional' | 'virtualStoreDir' | 'workspaceConcurrency' | 'workspaceDir' | 'workspacePackagePatterns' | 'extraEnv' | 'resolutionMode' | 'ignoreWorkspaceCycles' | 'disallowWorkspaceCycles' | 'updateConfig' | 'overrides' | 'packageExtensions' | 'supportedArchitectures' | 'packageConfigs'> & CreateStoreControllerOptions & Partial<Pick<Config, 'globalPkgDir'>> & {
+    argv: {
+        original: string[];
+    };
+    fixLockfile?: boolean;
+    frozenLockfileIfExists?: boolean;
+    useBetaCli?: boolean;
+    pruneDirectDependencies?: boolean;
+    pruneLockfileImporters?: boolean;
+    pruneStore?: boolean;
+    recursive?: boolean;
+    resolutionOnly?: boolean;
+    saveLockfile?: boolean;
+    workspace?: boolean;
+    includeOnlyPackageFiles?: boolean;
+    confirmModulesPurge?: boolean;
+    pnpmfile: string[];
+} & Partial<Pick<Config, 'ci' | 'modulesCacheMaxAge' | 'pnpmHomeDir' | 'preferWorkspacePackages' | 'useLockfile' | 'symlink'>>;
+export declare function handler(opts: InstallCommandOptions & {
+    _calledFromLink?: boolean;
+}): Promise<void>;

package/lib/install.js

@@ -0,0 +1,281 @@
+import { FILTERING, OPTIONS, OUTPUT_OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { PnpmError } from '@pnpm/error';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { getFetchFullMetadata } from './getFetchFullMetadata.js';
+import { installDeps } from './installDeps.js';
+export function rcOptionsTypes() {
+    return pick([
+        'cache-dir',
+        'child-concurrency',
+        'cpu',
+        'dangerously-allow-all-builds',
+        'dev',
+        'engine-strict',
+        'fetch-retries',
+        'fetch-retry-factor',
+        'fetch-retry-maxtimeout',
+        'fetch-retry-mintimeout',
+        'fetch-timeout',
+        'frozen-lockfile',
+        'global-dir',
+        'global-pnpmfile',
+        'global',
+        'hoist',
+        'hoist-pattern',
+        'https-proxy',
+        'ignore-pnpmfile',
+        'ignore-scripts',
+        'optimistic-repeat-install',
+        'os',
+        'libc',
+        'link-workspace-packages',
+        'lockfile-dir',
+        'lockfile-directory',
+        'lockfile-only',
+        'lockfile',
+        'merge-git-branch-lockfiles',
+        'merge-git-branch-lockfiles-branch-pattern',
+        'modules-dir',
+        'network-concurrency',
+        'node-linker',
+        'noproxy',
+        'package-import-method',
+        'pnpmfile',
+        'prefer-frozen-lockfile',
+        'prefer-offline',
+        'production',
+        'proxy',
+        'public-hoist-pattern',
+        'registry',
+        'reporter',
+        'save-workspace-protocol',
+        'scripts-prepend-node-path',
+        'shamefully-flatten',
+        'shamefully-hoist',
+        'shared-workspace-lockfile',
+        'side-effects-cache-readonly',
+        'side-effects-cache',
+        'store-dir',
+        'strict-peer-dependencies',
+        'trust-policy',
+        'trust-policy-exclude',
+        'trust-policy-ignore-after',
+        'offline',
+        'only',
+        'optional',
+        'unsafe-perm',
+        'verify-store-integrity',
+        'virtual-store-dir',
+        'virtual-store-only',
+    ], allTypes);
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    ...pick(['force'], allTypes),
+    'fix-lockfile': Boolean,
+    'resolution-only': Boolean,
+    recursive: Boolean,
+});
+export const shorthands = {
+    D: '--dev',
+    P: '--production',
+};
+export const commandNames = ['install', 'i'];
+export function help() {
+    return renderHelp({
+        aliases: ['i'],
+        description: 'Installs all dependencies of the project in the current working directory. \
+When executed inside a workspace, installs all dependencies of all projects.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Run installation recursively in every package found in subdirectories. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    OPTIONS.ignoreScripts,
+                    OPTIONS.offline,
+                    OPTIONS.preferOffline,
+                    OPTIONS.globalDir,
+                    {
+                        description: "Packages in `devDependencies` won't be installed",
+                        name: '--prod',
+                        shortAlias: '-P',
+                    },
+                    {
+                        description: 'Only `devDependencies` are installed',
+                        name: '--dev',
+                        shortAlias: '-D',
+                    },
+                    {
+                        description: 'Skip reinstall if the workspace state is up-to-date',
+                        name: '--optimistic-repeat-install',
+                    },
+                    {
+                        description: '`optionalDependencies` are not installed',
+                        name: '--no-optional',
+                    },
+                    {
+                        description: `Don't read or generate a \`${WANTED_LOCKFILE}\` file`,
+                        name: '--no-lockfile',
+                    },
+                    {
+                        description: `Dependencies are not downloaded. Only \`${WANTED_LOCKFILE}\` is updated`,
+                        name: '--lockfile-only',
+                    },
+                    {
+                        description: "Don't generate a lockfile and fail if an update is needed. This setting is on by default in CI environments, so use --no-frozen-lockfile if you need to disable it for some reason",
+                        name: '--[no-]frozen-lockfile',
+                    },
+                    {
+                        description: `If the available \`${WANTED_LOCKFILE}\` satisfies the \`package.json\` then perform a headless installation`,
+                        name: '--prefer-frozen-lockfile',
+                    },
+                    {
+                        description: `The directory in which the ${WANTED_LOCKFILE} of the package will be created. Several projects may share a single lockfile.`,
+                        name: '--lockfile-dir <dir>',
+                    },
+                    {
+                        description: 'Fix broken lockfile entries automatically',
+                        name: '--fix-lockfile',
+                    },
+                    {
+                        description: 'Merge lockfiles were generated on git branch',
+                        name: '--merge-git-branch-lockfiles',
+                    },
+                    {
+                        description: 'The directory in which dependencies will be installed (instead of node_modules)',
+                        name: '--modules-dir <dir>',
+                    },
+                    {
+                        description: 'Dependencies inside the modules directory will have access only to their listed dependencies',
+                        name: '--no-hoist',
+                    },
+                    {
+                        description: 'All the subdeps will be hoisted into the root node_modules. Your code will have access to them',
+                        name: '--shamefully-hoist',
+                    },
+                    {
+                        description: 'Hoist all dependencies matching the pattern to `node_modules/.pnpm/node_modules`. \
+The default pattern is * and matches everything. Hoisted packages can be required \
+by any dependencies, so it is an emulation of a flat node_modules',
+                        name: '--hoist-pattern <pattern>',
+                    },
+                    {
+                        description: 'Hoist all dependencies matching the pattern to the root of the modules directory',
+                        name: '--public-hoist-pattern <pattern>',
+                    },
+                    OPTIONS.storeDir,
+                    OPTIONS.virtualStoreDir,
+                    {
+                        description: 'Maximum number of concurrent network requests',
+                        name: '--network-concurrency <number>',
+                    },
+                    {
+                        description: 'Controls the number of child processes run parallelly to build node modules',
+                        name: '--child-concurrency <number>',
+                    },
+                    {
+                        description: 'Disable pnpm hooks defined in .pnpmfile.cjs',
+                        name: '--ignore-pnpmfile',
+                    },
+                    {
+                        description: 'Ignore pnpm-workspace.yaml if exists in the parent directory, and treat the installation as normal non-workspace installation.',
+                        name: '--ignore-workspace',
+                    },
+                    {
+                        description: "If false, doesn't check whether packages in the store were mutated",
+                        name: '--[no-]verify-store-integrity',
+                    },
+                    {
+                        description: 'Fail on missing or invalid peer dependencies',
+                        name: '--strict-peer-dependencies',
+                    },
+                    {
+                        description: "Fail when a package's trust level is downgraded (e.g., from a trusted publisher to provenance only or no trust evidence)",
+                        name: '--trust-policy no-downgrade',
+                    },
+                    {
+                        description: 'Exclude specific packages from trust policy checks',
+                        name: '--trust-policy-exclude <package-spec>',
+                    },
+                    {
+                        description: 'Ignore trust downgrades for packages published more than specified minutes ago',
+                        name: '--trust-policy-ignore-after <minutes>',
+                    },
+                    {
+                        description: 'Clones/hardlinks or copies packages. The selected method depends from the file system',
+                        name: '--package-import-method auto',
+                    },
+                    {
+                        description: 'Hardlink packages from the store',
+                        name: '--package-import-method hardlink',
+                    },
+                    {
+                        description: 'Copy packages from the store',
+                        name: '--package-import-method copy',
+                    },
+                    {
+                        description: 'Clone (aka copy-on-write) packages from the store',
+                        name: '--package-import-method clone',
+                    },
+                    {
+                        description: 'Force reinstall dependencies: refetch packages modified in store, \
+recreate a lockfile and/or modules directory created by a non-compatible version of pnpm. \
+Install all optionalDependencies even when they don\'t satisfy the current environment(cpu, os, arch)',
+                        name: '--force',
+                    },
+                    {
+                        description: 'Use or cache the results of (pre/post)install hooks',
+                        name: '--side-effects-cache',
+                    },
+                    {
+                        description: 'Only use the side effects cache if present, do not create it for new packages',
+                        name: '--side-effects-cache-readonly',
+                    },
+                    {
+                        description: 'Re-runs resolution: useful for printing out peer dependency issues',
+                        name: '--resolution-only',
+                    },
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            OUTPUT_OPTIONS,
+            FILTERING,
+        ],
+        url: docsUrl('install'),
+        usages: ['pnpm install [options]'],
+    });
+}
+export async function handler(opts) {
+    if (opts.global && !opts._calledFromLink) {
+        throw new PnpmError('GLOBAL_INSTALL_NOT_SUPPORTED', '"pnpm install -g" is not supported. Use "pnpm add -g <pkg>" to install global packages.');
+    }
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+    const installDepsOptions = {
+        ...opts,
+        frozenLockfileIfExists: opts.frozenLockfileIfExists ?? (opts.ci && !opts.lockfileOnly &&
+            typeof opts.frozenLockfile === 'undefined' &&
+            typeof opts.preferFrozenLockfile === 'undefined'),
+        include,
+        includeDirect: include,
+        fetchFullMetadata: getFetchFullMetadata(opts),
+    };
+    if (opts.resolutionOnly) {
+        installDepsOptions.lockfileOnly = true;
+        installDepsOptions.forceFullResolution = true;
+    }
+    return installDeps(installDepsOptions, []);
+}
+//# sourceMappingURL=install.js.map