feat: expose package manager detection and download APIs

crates/vite_install/src/lib.rs

@@ -4,4 +4,7 @@ pub mod package_manager;
 mod request;
 mod shim;
 
-pub use package_manager::{PackageManager, PackageManagerType};
+pub use package_manager::{
+ PackageManager, PackageManagerType, download_package_manager,
+ get_package_manager_type_and_version,
+};

crates/vite_install/src/package_manager.rs

@@ -92,45 +92,23 @@ impl PackageManagerBuilder {
  /// Detect the package manager from the current working directory.
  pub async fn build(self) -> Result<PackageManager, Error> {
  let workspace_root = find_workspace_root(&self.cwd)?;
- let (package_manager_type, mut version, mut hash) =
+ let (package_manager_type, version_or_latest, hash) =
  get_package_manager_type_and_version(&workspace_root, self.client_override)?;
 
- let mut package_name = package_manager_type.to_string();
- let mut should_update_package_manager_field = false;
-
- if version == "latest" {
- version = get_latest_version(package_manager_type).await?;
- should_update_package_manager_field = true;
- hash = None; // Reset hash when fetching latest since hash is version-specific
- }
-
- // handle yarn >= 2.0.0 to use `@yarnpkg/cli-dist` as package name
- // @see https://github.com/nodejs/corepack/blob/main/config.json#L135
- if matches!(package_manager_type, PackageManagerType::Yarn) {
- let version_req = VersionReq::parse(">=2.0.0")?;
- if version_req.matches(&Version::parse(&version)?) {
- package_name = "@yarnpkg/cli-dist".to_string();
- }
- }
-
  // only download the package manager if it's not already downloaded
- let install_dir = download_package_manager(
- package_manager_type,
- &package_name,
- &version,
- hash.as_deref(),
- )
- .await?;
+ let (install_dir, package_name, version) =
+ download_package_manager(package_manager_type, &version_or_latest, hash.as_deref())
+ .await?;
 
- if should_update_package_manager_field {
+ if version_or_latest != version {
  // auto set `packageManager` field in package.json
  let package_json_path = workspace_root.path.join("package.json");
  set_package_manager_field(&package_json_path, package_manager_type, &version).await?;
  }
 
  Ok(PackageManager {
  client: package_manager_type,
- package_name: package_name.into(),
+ package_name,
  version,
  hash,
  bin_name: package_manager_type.to_string().into(),
@@ -200,7 +178,7 @@ impl PackageManager {
 }
 
 /// Get the package manager name, version and optional hash from the workspace root.
-fn get_package_manager_type_and_version(
+pub fn get_package_manager_type_and_version(
  workspace_root: &WorkspaceRoot,
  default: Option<PackageManagerType>,
 ) -> Result<(PackageManagerType, Str, Option<Str>), Error> {
@@ -321,17 +299,32 @@ async fn get_latest_version(package_manager_type: PackageManagerType) -> Result<
 
 /// Download the package manager and extract it to the cache directory.
 /// Return the install directory, e.g. $`CACHE_DIR/vite/package_manager/pnpm/10.0.0/pnpm`
-async fn download_package_manager(
+pub async fn download_package_manager(
  package_manager_type: PackageManagerType,
- package_name: &str,
- version: &str,
+ version_or_latest: &str,
  expected_hash: Option<&str>,
-) -> Result<AbsolutePathBuf, Error> {
- let tgz_url = get_npm_package_tgz_url(package_name, version);
+) -> Result<(AbsolutePathBuf, Str, Str), Error> {
+ let version: Str = if version_or_latest == "latest" {
+ get_latest_version(package_manager_type).await?
+ } else {
+ version_or_latest.into()
+ };
+
+ let mut package_name: Str = package_manager_type.to_string().into();
+ // handle yarn >= 2.0.0 to use `@yarnpkg/cli-dist` as package name
+ // @see https://github.com/nodejs/corepack/blob/main/config.json#L135
+ if matches!(package_manager_type, PackageManagerType::Yarn) {
+ let version_req = VersionReq::parse(">=2.0.0")?;
+ if version_req.matches(&Version::parse(&version)?) {
+ package_name = "@yarnpkg/cli-dist".into();
+ }
+ }
+
+ let tgz_url = get_npm_package_tgz_url(&package_name, &version);
  let cache_dir = get_cache_dir()?;
  let bin_name = package_manager_type.to_string();
  // $CACHE_DIR/vite/package_manager/pnpm/10.0.0
- let target_dir = cache_dir.join("package_manager").join(&bin_name).join(version);
+ let target_dir = cache_dir.join("package_manager").join(&bin_name).join(&version);
  let install_dir = target_dir.join(&bin_name);
 
  // If all shims are already exists, return the target directory
@@ -342,7 +335,7 @@ async fn download_package_manager(
  && is_exists_file(bin_file.with_extension("cmd"))?
  && is_exists_file(bin_file.with_extension("ps1"))?
  {
- return Ok(install_dir);
+ return Ok((install_dir, package_name, version));
  }
 
  // $CACHE_DIR/vite/package_manager/pnpm/{tmp_name}
@@ -360,7 +353,7 @@ async fn download_package_manager(
  {
  Error::PackageManagerVersionNotFound {
  name: package_manager_type.to_string().into(),
- version: version.into(),
+ version: version.clone(),
  url: tgz_url.into(),
  }
  } else {
@@ -388,7 +381,7 @@ async fn download_package_manager(
  // the installation while we were downloading
  if is_exists_file(&bin_file)? {
  tracing::debug!("bin_file already exists after lock acquisition, skip rename");
- return Ok(install_dir);
+ return Ok((install_dir, package_name, version));
  }
 
  // rename $target_dir_tmp to $target_dir
@@ -400,7 +393,7 @@ async fn download_package_manager(
  tracing::debug!("Create shim files for {}", bin_name);
  create_shim_files(package_manager_type, &bin_prefix).await?;
 
- Ok(install_dir)
+ Ok((install_dir, package_name, version))
 }
 
 /// Remove the directory and all its contents.
@@ -1365,24 +1358,23 @@ mod tests {
 
  #[tokio::test]
  async fn test_download_package_manager() {
- let result =
- download_package_manager(PackageManagerType::Yarn, "@yarnpkg/cli-dist", "4.9.2", None)
- .await;
+ let result = download_package_manager(PackageManagerType::Yarn, "4.9.2", None).await;
  assert!(result.is_ok());
- let target_dir = result.unwrap();
+ let (target_dir, package_name, version) = result.unwrap();
  println!("result: {target_dir:?}");
  assert!(is_exists_file(target_dir.join("bin/yarn")).unwrap());
  assert!(is_exists_file(target_dir.join("bin/yarn.cmd")).unwrap());
+ assert_eq!(package_name, "@yarnpkg/cli-dist");
+ assert_eq!(version, "4.9.2");
 
  // again should skip download
- let result =
- download_package_manager(PackageManagerType::Yarn, "@yarnpkg/cli-dist", "4.9.2", None)
- .await;
+ let result = download_package_manager(PackageManagerType::Yarn, "4.9.2", None).await;
  assert!(result.is_ok());
- let target_dir = result.unwrap();
+ let (target_dir, package_name, version) = result.unwrap();
  assert!(is_exists_file(target_dir.join("bin/yarn")).unwrap());
  assert!(is_exists_file(target_dir.join("bin/yarn.cmd")).unwrap());
-
+ assert_eq!(package_name, "@yarnpkg/cli-dist");
+ assert_eq!(version, "4.9.2");
  remove_dir_all_force(target_dir).await.unwrap();
  }
 

packages/cli/binding/Cargo.toml

@@ -25,6 +25,7 @@ vite_install = { workspace = true }
 vite_path = { workspace = true }
 vite_str = { workspace = true }
 vite_task = { workspace = true }
+vite_workspace = { workspace = true }
 
 [build-dependencies]
 napi-build = { workspace = true }

packages/cli/binding/__tests__/detect-workspace.spec.ts

@@ -0,0 +1,52 @@
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { expect, test } from 'vitest';
+
+import { detectWorkspace } from '../index.js';
+
+const fixtures = path.join(import.meta.dirname, 'fixtures');
+
+test('should detect pnpm monorepo workspace successfully', async () => {
+ const cwd = path.join(fixtures, 'pnpm-monorepo');
+ const result = await detectWorkspace(cwd);
+ expect(result.packageManagerName).toBe('pnpm');
+ expect(result.packageManagerVersion).toBe('10.19.0');
+ expect(result.isMonorepo).toBe(true);
+ expect(result.root).toBe(cwd);
+
+ // detect from sub directory
+ const subCwd = path.join(cwd, 'packages', 'sub-package');
+ const subResult = await detectWorkspace(subCwd);
+ expect(subResult.packageManagerName).toBe('pnpm');
+ expect(subResult.packageManagerVersion).toBe('10.19.0');
+ expect(subResult.isMonorepo).toBe(true);
+ expect(subResult.root).toBe(cwd);
+});
+
+test('should detect npm monorepo workspace successfully', async () => {
+ const cwd = path.join(fixtures, 'npm-monorepo');
+ const result = await detectWorkspace(cwd);
+ expect(result.packageManagerName).toBe('npm');
+ expect(result.packageManagerVersion).toBe('10.19.0');
+ expect(result.isMonorepo).toBe(true);
+ expect(result.root).toBe(cwd);
+});
+
+// FIXME: currently it will always find vite-plus, there is a problem here
+test.skip('should detect npm project successfully', async () => {
+ const cwd = path.join(fixtures, 'npm-project');
+ const result = await detectWorkspace(cwd);
+ expect(result.packageManagerName).toBe('npm');
+ expect(result.packageManagerVersion).toBe('10.19.0');
+ expect(result.isMonorepo).toBe(false);
+ expect(result.root).toBe(cwd);
+});
+
+test('should detect workspace failed with not exists directory', async () => {
+ const result = await detectWorkspace(path.join(tmpdir(), 'not-exists'));
+ expect(result.packageManagerName).toBeUndefined();
+ expect(result.packageManagerVersion).toBeUndefined();
+ expect(result.isMonorepo).toBe(false);
+ expect(result.root).toBeUndefined();
+});

packages/cli/binding/__tests__/download-package-manager.spec.ts

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest';
+
+import { downloadPackageManager } from '../index.js';
+
+test('should download package manager successfully', async () => {
+ const result = await downloadPackageManager({
+ name: 'pnpm',
+ version: 'latest',
+ });
+ expect(result.name).toBe('pnpm');
+ expect(result.packageName).toBe('pnpm');
+ expect(result.version).toMatch(/^\d+\.\d+\.\d+$/);
+ expect(result.installDir).toBeTruthy();
+ expect(result.binPrefix).toMatch(/bin$/);
+});

packages/cli/binding/__tests__/fixtures/npm-monorepo/package.json

@@ -0,0 +1,8 @@
+{
+ "name": "npm-monorepo",
+ "version": "1.0.0",
+ "packageManager": "npm@10.19.0",
+ "workspaces": [
+ "packages/*"
+ ]
+}

packages/cli/binding/__tests__/fixtures/npm-project/package.json

@@ -0,0 +1,5 @@
+{
+ "name": "npm-project",
+ "version": "1.0.0",
+ "packageManager": "npm@10.19.0"
+}

packages/cli/binding/__tests__/fixtures/pnpm-monorepo/package.json

@@ -0,0 +1,5 @@
+{
+ "name": "pnpm-monorepo",
+ "version": "1.0.0",
+ "packageManager": "pnpm@10.19.0"
+}

packages/cli/binding/__tests__/fixtures/pnpm-monorepo/packages/foo/package.json

@@ -0,0 +1,3 @@
+{
+ "name": "pnpm-monorepo-foo"
+}

packages/cli/binding/__tests__/fixtures/pnpm-monorepo/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+ - packages/*

packages/cli/binding/index.d.ts

@@ -28,6 +28,89 @@ export interface CliOptions {
  resolveUniversalViteConfig: ((err: Error | null, arg: string) => Promise<string>)
 }
 
+/**
+ * Detect the workspace root and package manager type and version
+ *
+ * ## Parameters
+ *
+ * - `cwd`: The current working directory to detect the workspace root
+ *
+ * ## Returns
+ *
+ * Returns a `DetectWorkspaceResult` containing:
+ * - The name of the package manager
+ * - The version of the package manager
+ * - Whether the workspace is a monorepo
+ * - The workspace root, where the package.json file is located.
+ *
+ * ## Example
+ *
+ * ```javascript
+ * const result = await detectWorkspace("/path/to/workspace");
+ * console.log(`Package manager name: ${result.package_manager_name}`);
+ * console.log(`Package manager version: ${result.package_manager_version}`);
+ * console.log(`Is monorepo: ${result.is_monorepo}`);
+ * console.log(`Workspace root: ${result.root}`);
+ * ```
+ */
+export declare function detectWorkspace(cwd: string): Promise<DetectWorkspaceResult>
+
+export interface DetectWorkspaceResult {
+ packageManagerName?: string
+ packageManagerVersion?: string
+ isMonorepo: boolean
+ root?: string
+}
+
+/**
+ * Download a package manager
+ *
+ * ## Parameters
+ *
+ * - `options`: Configuration for the package manager to download, including:
+ * - `name`: The name of the package manager
+ * - `version`: The version of the package manager
+ * - `expected_hash`: The expected hash of the package manager
+ *
+ * ## Returns
+ *
+ * Returns a `DownloadPackageManagerResult` containing:
+ * - The name of the package manager
+ * - The install directory of the package manager
+ * - The binary prefix of the package manager
+ * - The package name of the package manager
+ * - The version of the package manager
+ *
+ * ## Example
+ *
+ * ```javascript
+ * const result = await downloadPackageManager({
+ * name: "pnpm",
+ * version: "latest",
+ * });
+ * console.log(`Package manager name: ${result.name}`);
+ * console.log(`Package manager install directory: ${result.install_dir}`);
+ * console.log(`Package manager binary prefix: ${result.bin_prefix}`);
+ * console.log(`Package manager package name: ${result.package_name}`);
+ * console.log(`Package manager version: ${result.version}`);
+ * ```
+ */
+export declare function downloadPackageManager(options: DownloadPackageManagerOptions): Promise<DownloadPackageManagerResult>
+
+export interface DownloadPackageManagerOptions {
+ name: string
+ version: string
+ expectedHash?: string
+}
+
+export interface DownloadPackageManagerResult {
+ name: string
+ installDir: string
+ binPrefix: string
+ packageName: string
+ version: string
+}
+
 /**
  * Result returned by JavaScript resolver functions.
  *

packages/cli/binding/index.js

@@ -575,6 +575,8 @@ if (!nativeBinding) {
  throw new Error(`Failed to load native binding`)
 }
 
-const { run, runCommand } = nativeBinding
+const { detectWorkspace, downloadPackageManager, run, runCommand } = nativeBinding
+export { detectWorkspace }
+export { downloadPackageManager }
 export { run }
 export { runCommand }