feat(core): support bun as a package manager

.husky/pre-push

@@ -1,6 +1,5 @@
 #!/usr/bin/env sh
-
+pnpm check-documentation-map &&
 pnpm check-lock-files &&
 pnpm check-commit &&
-pnpm documentation &&
 pnpm pretty-quick --check

package.json

@@ -253,7 +253,6 @@
     "react-refresh": "^0.10.0",
     "react-router-dom": "^6.21.2",
     "react-textarea-autosize": "^8.5.3",
-    "regenerator-runtime": "0.13.7",
     "resolve.exports": "1.1.0",
     "rollup": "^2.56.2",
     "rollup-plugin-copy": "^3.4.0",
@@ -373,4 +372,4 @@
       "documentation"
     ]
   }
-}
+}

packages/expo/src/generators/application/lib/create-application-files.ts

@@ -14,6 +14,7 @@ export function createApplicationFiles(host: Tree, options: NormalizedSchema) {
     npm: 'package-lock.json',
     yarn: 'yarn.lock',
     pnpm: 'pnpm-lock.yaml',
+    bun: 'bun.lockb',
   };
   const packageManager = detectPackageManager(host.root);
   const packageLockFile = packageManagerLockFile[packageManager];

packages/expo/src/migrations/update-16-1-4/update-eas-scripts.ts

@@ -19,6 +19,7 @@ export default function update(tree: Tree) {
     npm: 'package-lock.json',
     yarn: 'yarn.lock',
     pnpm: 'pnpm-lock.yaml',
+    bun: 'bun.lockb',
   };
 
   for (const [name, config] of projects.entries()) {

packages/nx/src/command-line/nx-commands.ts

@@ -53,7 +53,7 @@ export const parserConfiguration: Partial<yargs.ParserConfigurationOptions> = {
  * from the `.argv` call, so the object and it's relative scripts can
  * le executed correctly.
  */
-export const commandsObject = yargs
+export const commandsObject: any = yargs
   .parserConfiguration(parserConfiguration)
   .usage(chalk.bold('Smart Monorepos · Fast CI'))
   .demandCommand(1, '')

packages/nx/src/command-line/release/command-object.ts

@@ -115,8 +115,8 @@ export const yargsReleaseCommand: CommandModule<
           );
         }
         const nxJson = readNxJson();
-        if (argv.groups?.length) {
-          for (const group of argv.groups) {
+        if ((argv.groups as string[] | string)?.length) {
+          for (const group of argv.groups as string[] | string) {
             if (!nxJson.release?.groups?.[group]) {
               throw new Error(
                 `The specified release group "${group}" was not found in nx.json`

packages/nx/src/command-line/release/version.ts

@@ -534,7 +534,7 @@ function printAndFlushChanges(tree: Tree, isDryRun: boolean) {
           isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''
         }`
       );
-      printDiff('', f.content?.toString() || '');
+      printDiff('', f.content?.toString() ?? '');
     } else if (f.type === 'UPDATE') {
       console.error(
         `${chalk.white('UPDATE')} ${f.path}${

packages/nx/src/tasks-runner/pseudo-terminal.spec.ts

@@ -1,5 +1,7 @@
 import { getPseudoTerminal, PseudoTerminal } from './pseudo-terminal';
 
+jest.setTimeout(30000);
+
 describe('PseudoTerminal', () => {
   let terminal: PseudoTerminal;
   beforeAll(() => {

packages/nx/src/utils/command-line-utils.ts

@@ -39,7 +39,7 @@ export interface NxArgs {
 }
 
 export function createOverrides(__overrides_unparsed__: string[] = []) {
-  let overrides =
+  let overrides: any =
     yargsParser(__overrides_unparsed__, {
       configuration: {
         'camel-case-expansion': false,
@@ -121,7 +121,7 @@ export function splitArgsIntoNxArgsAndOverrides(
 
     // Allow setting base and head via environment variables (lower priority then direct command arguments)
     if (!nxArgs.base && process.env.NX_BASE) {
-      nxArgs.base = process.env.NX_BASE;
+      nxArgs.base = process.env.NX_BASE ?? 'main';
       if (options.printWarnings) {
         output.note({
           title: `No explicit --base argument provided, but found environment variable NX_BASE so using its value as the affected base: ${output.bold(
@@ -143,7 +143,7 @@ export function splitArgsIntoNxArgsAndOverrides(
 
     if (!nxArgs.base) {
       nxArgs.base =
-        nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+        nxJson?.defaultBase ?? nxJson?.affected?.defaultBase ?? 'main';
 
       // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
       if (
@@ -290,7 +290,7 @@ function getUntrackedFiles(): string[] {
   return parseGitOutput(`git ls-files --others --exclude-standard`);
 }
 
-function getMergeBase(base: string, head: string = 'HEAD') {
+function getMergeBase(base: string = 'main', head: string = 'HEAD') {
   try {
     return execSync(`git merge-base "${base}" "${head}"`, {
       maxBuffer: TEN_MEGABYTES,
@@ -314,7 +314,10 @@ function getMergeBase(base: string, head: string = 'HEAD') {
   }
 }
 
-function getFilesUsingBaseAndHead(base: string, head: string): string[] {
+function getFilesUsingBaseAndHead(
+  base: string = 'main',
+  head: string
+): string[] {
   return parseGitOutput(
     `git diff --name-only --no-renames --relative "${base}" "${head}"`
   );

packages/nx/src/utils/package-manager.spec.ts

@@ -16,65 +16,94 @@ describe('package-manager', () => {
           packageManager: 'pnpm',
         },
       });
+      jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
+        switch (p) {
+          case 'pnpm-lock.yaml':
+            return true;
+          case 'yarn.lock':
+            return false;
+          case 'package-lock.json':
+            return false;
+          case 'bun.lockb':
+            return false;
+          default:
+            return jest.requireActual('fs').existsSync(p);
+        }
+      });
       const packageManager = detectPackageManager();
       expect(packageManager).toEqual('pnpm');
     });
 
     it('should detect yarn package manager from yarn.lock', () => {
-      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({});
+      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({
+        cli: {
+          packageManager: 'yarn',
+        },
+      });
       jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
         switch (p) {
-          case 'yarn.lock':
-            return true;
           case 'pnpm-lock.yaml':
             return false;
+          case 'yarn.lock':
+            return true;
           case 'package-lock.json':
             return false;
+          case 'bun.lockb':
+            return false;
           default:
             return jest.requireActual('fs').existsSync(p);
         }
       });
       const packageManager = detectPackageManager();
       expect(packageManager).toEqual('yarn');
-      expect(fs.existsSync).toHaveBeenNthCalledWith(1, 'yarn.lock');
     });
 
-    it('should detect pnpm package manager from pnpm-lock.yaml', () => {
-      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({});
+    it('should detect package manager in nxJson', () => {
+      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({
+        cli: {
+          packageManager: 'bun',
+        },
+      });
       jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
         switch (p) {
+          case 'pnpm-lock.yaml':
+            return false;
           case 'yarn.lock':
             return false;
-          case 'pnpm-lock.yaml':
-            return true;
           case 'package-lock.json':
             return false;
+          case 'bun.lockb':
+            return true;
           default:
             return jest.requireActual('fs').existsSync(p);
         }
       });
       const packageManager = detectPackageManager();
-      expect(packageManager).toEqual('pnpm');
-      expect(fs.existsSync).toHaveBeenCalledTimes(3);
+      expect(packageManager).toEqual('bun');
     });
 
     it('should use npm package manager as default', () => {
-      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({});
+      jest.spyOn(configModule, 'readNxJson').mockReturnValueOnce({
+        cli: {
+          packageManager: 'npm',
+        },
+      });
       jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
         switch (p) {
-          case 'yarn.lock':
-            return false;
           case 'pnpm-lock.yaml':
             return false;
+          case 'yarn.lock':
+            return false;
           case 'package-lock.json':
+            return true;
+          case 'bun.lockb':
             return false;
           default:
             return jest.requireActual('fs').existsSync(p);
         }
       });
       const packageManager = detectPackageManager();
       expect(packageManager).toEqual('npm');
-      expect(fs.existsSync).toHaveBeenCalledTimes(5);
     });
   });
 

packages/nx/src/utils/package-manager.ts

@@ -13,7 +13,7 @@ import { workspaceRoot } from './workspace-root';
 
 const execAsync = promisify(exec);
 
-export type PackageManager = 'yarn' | 'pnpm' | 'npm';
+export type PackageManager = 'yarn' | 'pnpm' | 'npm' | 'bun';
 
 export interface PackageManagerCommands {
   preInstall?: string;
@@ -29,19 +29,26 @@ export interface PackageManagerCommands {
   run: (script: string, args: string) => string;
 }
 
+/**
+ * Detects which package manager is used in the workspace based on the lock file.
+ */
+function getPackageManager(dir: string = '') {
+  return existsSync(join(dir, 'yarn.lock'))
+    ? 'yarn'
+    : existsSync(join(dir, 'bun.lockb'))
+    ? 'bun'
+    : existsSync(join(dir, 'pnpm-lock.yaml')) ||
+      existsSync(join(dir, 'pnpm-workspace.yaml'))
+    ? 'pnpm'
+    : 'npm';
+}
+
 /**
  * Detects which package manager is used in the workspace based on the lock file.
  */
 export function detectPackageManager(dir: string = ''): PackageManager {
   const nxJson = readNxJson();
-  return (
-    nxJson.cli?.packageManager ??
-    (existsSync(join(dir, 'yarn.lock'))
-      ? 'yarn'
-      : existsSync(join(dir, 'pnpm-lock.yaml'))
-      ? 'pnpm'
-      : 'npm')
-  );
+  return nxJson.cli?.packageManager ?? getPackageManager(dir);
 }
 
 /**
@@ -142,6 +149,23 @@ export function getPackageManagerCommand(
         list: 'npm ls',
       };
     },
+    bun: () => {
+      // TODO: Remove this
+      process.env.npm_config_legacy_peer_deps ??= 'true';
+
+      return {
+        install: 'bun install',
+        ciInstall: 'bun install --no-cache',
+        updateLockFile: 'bun install --frozen-lockfile',
+        add: 'bun install',
+        addDev: 'bun install -D',
+        rm: 'bun rm',
+        exec: 'bun',
+        dlx: 'bunx',
+        run: (script: string, args: string) => `bun run ${script} -- ${args}`,
+        list: 'bun pm ls',
+      };
+    },
   };
 
   return commands[packageManager]();
@@ -230,7 +254,12 @@ export function copyPackageManagerConfigurationFiles(
   root: string,
   destination: string
 ) {
-  for (const packageManagerConfigFile of ['.npmrc', '.yarnrc', '.yarnrc.yml']) {
+  for (const packageManagerConfigFile of [
+    '.npmrc',
+    '.yarnrc',
+    '.yarnrc.yml',
+    'bunfig.toml',
+  ]) {
     // f is an absolute path, including the {workspaceRoot}.
     const f = findFileInPackageJsonDirectory(packageManagerConfigFile, root);
     if (f) {
@@ -243,6 +272,10 @@ export function copyPackageManagerConfigurationFiles(
           copyFileSync(f, destinationPath);
           break;
         }
+        case 'bunfig.toml': {
+          copyFileSync(f, destinationPath);
+          break;
+        }
         case '.yarnrc': {
           const updated = modifyYarnRcToFitNewDirectory(readFileIfExisting(f));
           writeFileSync(destinationPath, updated);
@@ -343,7 +376,7 @@ export async function packageRegistryView(
   args: string
 ): Promise<string> {
   let pm = detectPackageManager();
-  if (pm === 'yarn') {
+  if (pm === 'yarn' || pm === 'bun') {
     /**
      * yarn has `yarn info` but it behaves differently than (p)npm,
      * which makes it's usage unreliable
@@ -363,7 +396,7 @@ export async function packageRegistryPack(
   version: string
 ): Promise<{ tarballPath: string }> {
   let pm = detectPackageManager();
-  if (pm === 'yarn') {
+  if (pm === 'yarn' || pm === 'bun') {
     /**
      * `(p)npm pack` will download a tarball of the specified version,
      * whereas `yarn` pack creates a tarball of the active workspace, so it