feat: add Bun to init command (#2073)

* feat: support bun package manager

* rename function & fix tests

* check if bun is available

* create --pm flag and deprecate --npm

* prioritize flag over user agent

* update checkPackageManagerAvailability fn

* set yarn as default PM if user agent not available

* add tests for bun

Author: TMisiukiewicz

docs/commands.md

@@ -97,9 +97,15 @@ module.exports = {
 Skip dependencies installation
 
 #### `--npm`
+> [!WARNING]  
+> `--npm` is deprecated and will be removed in the future. Please use `--pm npm` instead.
 
 Force use of npm during initialization
 
+#### `--pm <string>`
+
+Use specific package manager to initialize the project. Available options: `yarn`, `npm`, `bun`. Default: `yarn`
+
 #### `--package-name <string>`
 
 Create project with custom package name for Android and bundle identifier for iOS. The correct package name should:

packages/cli-clean/src/clean.ts

@@ -163,6 +163,17 @@ export async function clean(
           : []),
       ],
     },
+    bun: {
+      description: 'Bun cache',
+      tasks: [
+        {
+          label: 'Clean Bun cache',
+          action: async () => {
+            await execa('bun', ['pm', 'cache', 'rm'], {cwd: projectRoot});
+          },
+        },
+      ],
+    },
     watchman: {
       description: 'Stop Watchman and delete its cache',
       tasks: [

packages/cli-doctor/src/tools/checkInstallation.ts

@@ -4,6 +4,7 @@ import commandExists from 'command-exists';
 export enum PACKAGE_MANAGERS {
   YARN = 'YARN',
   NPM = 'NPM',
+  BUN = 'BUN',
 }
 
 const isSoftwareNotInstalled = async (command: string): Promise<boolean> => {

packages/cli-doctor/src/tools/versionRanges.ts

@@ -3,6 +3,7 @@ export default {
   NODE_JS: '>= 18',
   YARN: '>= 1.10.x',
   NPM: '>= 4.x',
+  BUN: '>= 1.0.0',
   RUBY: '>= 2.6.10',
   JAVA: '>= 17 <= 20',
   // Android

packages/cli-doctor/src/types.ts

@@ -23,6 +23,7 @@ export type EnvironmentInfo = {
     Node: AvailableInformation;
     Yarn: AvailableInformation;
     npm: AvailableInformation;
+    bun: AvailableInformation;
     Watchman: AvailableInformation;
   };
   Managers: {

packages/cli/src/commands/init/__tests__/template.test.ts

@@ -22,10 +22,10 @@ afterEach(() => {
 test('installTemplatePackage', async () => {
   jest.spyOn(PackageManger, 'install').mockImplementationOnce(() => null);
 
-  await installTemplatePackage(TEMPLATE_NAME, TEMPLATE_SOURCE_DIR, true);
+  await installTemplatePackage(TEMPLATE_NAME, TEMPLATE_SOURCE_DIR, 'npm');
 
   expect(PackageManger.install).toHaveBeenCalledWith([TEMPLATE_NAME], {
-    preferYarn: false,
+    packageManager: 'npm',
     silent: true,
     root: TEMPLATE_SOURCE_DIR,
   });

packages/cli/src/commands/init/index.ts

@@ -20,6 +20,11 @@ export default {
       name: '--npm',
       description: 'Forces using npm for initialization',
     },
+    {
+      name: '--pm <string>',
+      description:
+        'Use specific package manager to initialize the project. Available options: `yarn`, `npm`, `bun`. Default: `yarn`',
+    },
     {
       name: '--directory <string>',
       description: 'Uses a custom directory instead of `<projectName>`.',

packages/cli/src/commands/init/init.ts

@@ -21,12 +21,16 @@ import * as PackageManager from '../../tools/packageManager';
 import {installPods} from '@react-native-community/cli-doctor';
 import banner from './banner';
 import TemplateAndVersionError from './errors/TemplateAndVersionError';
+import {getBunVersionIfAvailable} from '../../tools/bun';
+import {getNpmVersionIfAvailable} from '../../tools/npm';
+import {getYarnVersionIfAvailable} from '../../tools/yarn';
 
 const DEFAULT_VERSION = 'latest';
 
 type Options = {
   template?: string;
   npm?: boolean;
+  pm?: PackageManager.PackageManager;
   directory?: string;
   displayName?: string;
   title?: string;
@@ -39,6 +43,7 @@ interface TemplateOptions {
   projectName: string;
   templateUri: string;
   npm?: boolean;
+  pm?: PackageManager.PackageManager;
   directory: string;
   projectTitle?: string;
   skipInstall?: boolean;
@@ -82,6 +87,7 @@ async function createFromTemplate({
   projectName,
   templateUri,
   npm,
+  pm,
   directory,
   projectTitle,
   skipInstall,
@@ -90,6 +96,24 @@ async function createFromTemplate({
   logger.debug('Initializing new project');
   logger.log(banner);
 
+  let packageManager = pm;
+
+  if (pm) {
+    packageManager = pm;
+  } else {
+    const userAgentPM = userAgentPackageManager();
+    // if possible, use the package manager from the user agent. Otherwise fallback to default (yarn)
+    packageManager = userAgentPM || 'yarn';
+  }
+
+  if (npm) {
+    logger.warn(
+      'Flag --npm is deprecated and will be removed soon. In the future, please use --pm npm instead.',
+    );
+
+    packageManager = 'npm';
+  }
+
   const projectDirectory = await setProjectDirectory(directory);
 
   const loader = getLoader({text: 'Downloading template'});
@@ -100,7 +124,11 @@ async function createFromTemplate({
   try {
     loader.start();
 
-    await installTemplatePackage(templateUri, templateSourceDir, npm);
+    await installTemplatePackage(
+      templateUri,
+      templateSourceDir,
+      packageManager,
+    );
 
     loader.succeed();
     loader.start('Copying template');
@@ -137,7 +165,7 @@ async function createFromTemplate({
 
     if (!skipInstall) {
       await installDependencies({
-        npm,
+        packageManager,
         loader,
         root: projectDirectory,
       });
@@ -153,18 +181,18 @@ async function createFromTemplate({
 }
 
 async function installDependencies({
-  npm,
+  packageManager,
   loader,
   root,
 }: {
-  npm?: boolean;
+  packageManager: PackageManager.PackageManager;
   loader: Loader;
   root: string;
 }) {
   loader.start('Installing dependencies');
 
   await PackageManager.installAll({
-    preferYarn: !npm,
+    packageManager,
     silent: true,
     root,
   });
@@ -176,6 +204,20 @@ async function installDependencies({
   loader.succeed();
 }
 
+function checkPackageManagerAvailability(
+  packageManager: PackageManager.PackageManager,
+) {
+  if (packageManager === 'bun') {
+    return getBunVersionIfAvailable();
+  } else if (packageManager === 'npm') {
+    return getNpmVersionIfAvailable();
+  } else if (packageManager === 'yarn') {
+    return getYarnVersionIfAvailable();
+  }
+
+  return false;
+}
+
 function createTemplateUri(options: Options, version: string): string {
   const isTypescriptTemplate =
     options.template === 'react-native-template-typescript';
@@ -202,13 +244,32 @@ async function createProject(
     projectName,
     templateUri,
     npm: options.npm,
+    pm: options.pm,
     directory,
     projectTitle: options.title,
     skipInstall: options.skipInstall,
     packageName: options.packageName,
   });
 }
 
+function userAgentPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+
+  if (userAgent) {
+    if (userAgent.startsWith('yarn')) {
+      return 'yarn';
+    }
+    if (userAgent.startsWith('npm')) {
+      return 'npm';
+    }
+    if (userAgent.startsWith('bun')) {
+      return 'bun';
+    }
+  }
+
+  return null;
+}
+
 export default (async function initialize(
   [projectName]: Array<string>,
   options: Options,
@@ -223,6 +284,13 @@ export default (async function initialize(
   const version = options.version || DEFAULT_VERSION;
   const directoryName = path.relative(root, options.directory || projectName);
 
+  if (options.pm && !checkPackageManagerAvailability(options.pm)) {
+    logger.error(
+      'Seems like the package manager you want to use is not installed. Please install it or choose another package manager.',
+    );
+    return;
+  }
+
   await createProject(projectName, directoryName, version, options);
 
   const projectFolder = path.join(root, directoryName);

packages/cli/src/commands/init/template.ts

@@ -17,18 +17,18 @@ export type TemplateConfig = {
 export async function installTemplatePackage(
   templateName: string,
   root: string,
-  npm?: boolean,
+  packageManager: PackageManager.PackageManager,
 ) {
   logger.debug(`Installing template from ${templateName}`);
 
   await PackageManager.init({
-    preferYarn: !npm,
+    packageManager,
     silent: true,
     root,
   });
 
   return PackageManager.install([templateName], {
-    preferYarn: !npm,
+    packageManager,
     silent: true,
     root,
   });