Open History to see the last commit
1import type { Environment } from './types.js'
2
3export const SUPPORTED_PACKAGE_MANAGERS = [
4 'npm',
5 'yarn',
6 'pnpm',
7 'bun',
8 'deno',
9] as const
10export type PackageManager = (typeof SUPPORTED_PACKAGE_MANAGERS)[number]
11export const DEFAULT_PACKAGE_MANAGER: PackageManager = 'npm'
12
13export function validatePackageManagerSupport(
14 packageManager: PackageManager,
15 addOns: Array<{
16 name: string
17 supportedPackageManagers?: Array<PackageManager>
18 }>,
19) {
20 const unsupported = addOns.find(
21 (addOn) =>
22 addOn.supportedPackageManagers &&
23 !addOn.supportedPackageManagers.includes(packageManager),
24 )
25
26 const supportedPackageManagers = unsupported?.supportedPackageManagers
27 if (!unsupported || !supportedPackageManagers) return
28
29 throw new Error(
30 `${unsupported.name} does not support the ${packageManager} package manager. Choose ${supportedPackageManagers.join(', ')}.`,
31 )
32}
33
34export function getPackageManager(): PackageManager | undefined {
35 const userAgent = process.env.npm_config_user_agent
36
37 if (userAgent === undefined) {
38 return DEFAULT_PACKAGE_MANAGER
39 }
40
41 const packageManager = SUPPORTED_PACKAGE_MANAGERS.find((manager) =>
42 userAgent.startsWith(manager),
43 )
44
45 return packageManager
46}
47
48export function getPackageManagerScriptCommand(
49 packagerManager: PackageManager,
50 args: Array<string> = [],
51) {
52 switch (packagerManager) {
53 case 'yarn':
54 return { command: 'yarn', args: ['run', ...args] }
55 case 'pnpm':
56 return { command: 'pnpm', args: [...args] }
57 case 'bun':
58 return { command: 'bun', args: ['--bun', 'run', ...args] }
59 case 'deno':
60 return { command: 'deno', args: ['task', ...args] }
61 default:
62 return { command: 'npm', args: ['run', ...args] }
63 }
64}
65
66// Full SemVer grammar requires non-empty suffixes and valid numeric identifiers.
67const PNPM_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/
68
69export async function detectPnpmVersion(environment: Environment, cwd: string) {
70 try {
71 const detected = await environment.getPackageManagerVersion?.('pnpm', cwd)
72 const version = typeof detected === 'string' ? detected.trim() : undefined
73 return version && PNPM_VERSION_PATTERN.test(version) ? version : undefined
74 } catch {
75 return undefined
76 }
77}
78
79export type ExecuteCommandOptions = {
80 /**
81 * Package names that are allowed to run postinstall/build scripts while the
82 * executed package is being installed. Supported by pnpm 10.2 and newer.
83 */
84 allowBuilds?: Array<string>
85 /** Unknown versions retain the compatible plain dlx command. */
86 packageManagerVersion?: string
87}
88
89export function getPackageManagerExecuteCommand(
90 packagerManager: PackageManager,
91 pkg: string,
92 args: Array<string> = [],
93 options: ExecuteCommandOptions = {},
94) {
95 switch (packagerManager) {
96 case 'yarn':
97 return { command: 'yarn', args: ['dlx', pkg, ...args] }
98 case 'pnpm': {
99 const version = options.packageManagerVersion
100 const parsedVersion = version?.match(PNPM_VERSION_PATTERN)
101 if (version !== undefined && !parsedVersion && options.allowBuilds?.length)
102 throw new Error(`Invalid pnpm version: ${version}`)
103 const supportsAllowBuild = parsedVersion && (
104 Number(parsedVersion[1]) > 10 ||
105 (Number(parsedVersion[1]) === 10 && Number(parsedVersion[2]) >= 2))
106 const allowBuildFlags = supportsAllowBuild
107 ? (options.allowBuilds || []).map((name) => `--allow-build=${name}`)
108 : []
109 return {
110 command: 'pnpm',
111 args: [...allowBuildFlags, 'dlx', pkg, ...args],
112 }
113 }
114 case 'bun':
115 return { command: 'bunx', args: ['--bun', pkg, ...args] }
116 case 'deno':
117 return { command: 'deno', args: ['run', `npm:${pkg}`, ...args] }
118 default:
119 return { command: 'npx', args: ['-y', pkg, ...args] }
120 }
121}
122
123export const INTENT_PACKAGE = '@tanstack/intent'
124
125export function intentCommand(
126 packageManager: PackageManager,
127 args: Array<string>,
128) {
129 const { command, args: commandArgs } = getPackageManagerExecuteCommand(
130 packageManager,
131 INTENT_PACKAGE,
132 args,
133 )
134 return [command, ...commandArgs].join(' ')
135}
136
137export function getPackageManagerInstallCommand(
138 packagerManager: PackageManager,
139 pkg?: string,
140 isDev: boolean = false,
141) {
142 if (pkg) {
143 switch (packagerManager) {
144 case 'yarn':
145 case 'pnpm':
146 return {
147 command: packagerManager,
148 args: ['add', pkg, isDev ? '--dev' : ''],
149 }
150 default:
151 return {
152 command: packagerManager,
153 args: ['install', pkg, isDev ? '-D' : ''],
154 }
155 }
156 } else {
157 return {
158 command: packagerManager,
159 args: ['install'],
160 }
161 }
162}
163
164export function packageManagerInstall(
165 environment: Environment,
166 cwd: string,
167 packagerManager: PackageManager,
168 pkg?: string,
169 options?: { updateLockfile?: boolean },
170) {
171 const { command, args: commandArgs } = getPackageManagerInstallCommand(
172 packagerManager,
173 pkg,
174 )
175 // Adding an add-on intentionally changes package.json, including in CI.
176 if (packagerManager === 'pnpm' && options?.updateLockfile && !pkg) {
177 commandArgs.push('--no-frozen-lockfile')
178 }
179 return environment.execute(command, commandArgs, cwd)
180}
181
182export function translateExecuteCommand(
183 packageManager: PackageManager,
184 command: {
185 command: string
186 args?: Array<string>
187 allowBuilds?: Array<string>
188 },
189 packageManagerVersion?: string,
190): { command: string; args: Array<string> } {
191 const args = command.args || []
192 const parsed = parseExecuteCommand(command.command, args)
193 if (parsed) {
194 return getPackageManagerExecuteCommand(
195 packageManager,
196 parsed.pkg,
197 parsed.args,
198 { allowBuilds: command.allowBuilds, packageManagerVersion },
199 )
200 }
201 return { command: command.command, args }
202}
203
204function parseExecuteCommand(
205 command: string,
206 args: Array<string>,
207): { pkg: string; args: Array<string> } | null {
208 if (command === 'npx') {
209 const filtered = args[0] === '-y' ? args.slice(1) : args
210 const [pkg, ...rest] = filtered
211 return pkg ? { pkg, args: rest } : null
212 }
213 if (command === 'pnpx' || command === 'bunx') {
214 const filtered = command === 'bunx' && args[0] === '--bun' ? args.slice(1) : args
215 const [pkg, ...rest] = filtered
216 return pkg ? { pkg, args: rest } : null
217 }
218 if ((command === 'pnpm' || command === 'yarn') && args[0] === 'dlx') {
219 const [, pkg, ...rest] = args
220 return pkg ? { pkg, args: rest } : null
221 }
222 if (command === 'deno' && args[0] === 'run' && args[1]?.startsWith('npm:')) {
223 const pkg = args[1].slice(4)
224 return pkg ? { pkg, args: args.slice(2) } : null
225 }
226 return null
227}
228
229export function packageManagerExecute(
230 environment: Environment,
231 cwd: string,
232 packagerManager: PackageManager,
233 pkg: string,
234 args: Array<string>,
235) {
236 const { command, args: commandArgs } = getPackageManagerExecuteCommand(
237 packagerManager,
238 pkg,
239 args,
240 )
241 return environment.execute(command, commandArgs, cwd)
242}