feat: new conversions

dist/npm-to-yarn.mjs

@@ -202,6 +202,12 @@ function yarnToNPM(_m, command) {
         return 'npm ' + command + "\n# couldn't auto-convert command";
     }
 }
+function pnpmToNpm() {
+    return 'pnpm to npm';
+}
+function bunToNpm() {
+    return 'bun to npm';
+}
 
 function convertInstallArgs$1(args) {
     if (args.includes('--global') || args.includes('-g')) {
@@ -352,6 +358,12 @@ function npmToYarn(_m, command) {
         return 'npm ' + command + "\n# couldn't auto-convert command";
     }
 }
+function pnpmToYarn() {
+    return 'pnpm to yarn';
+}
+function bunToYarn() {
+    return 'bun to yarn';
+}
 
 function convertPnpmInstallArgs(args) {
     return args.map(function (item) {
@@ -488,6 +500,13 @@ function npmToPnpm(_m, command) {
         return 'npm ' + command + "\n# couldn't auto-convert command";
     }
 }
+function yarnToPnpm(_m, command) {
+    var npmCommand = yarnToNPM(_m, command);
+    return npmCommand.replace(/npm(?: +([^&\n\r]*))?/gm, npmToPnpm);
+}
+function bunToPnpm() {
+    return 'bun to pnpm';
+}
 
 function convertInstallArgs(args) {
     // bun uses -g and --global flags
@@ -614,21 +633,95 @@ function npmToBun(_m, command) {
     var filtered = args.filter(Boolean).filter(function (arg) { return arg !== '--'; });
     return "".concat(cmd, " ").concat(filtered.join(' ')).concat(cmd === 'npm' ? "\n# couldn't auto-convert command" : '').replace('=', ' ');
 }
+function yarnToBun(_m, command) {
+    var npmCommand = yarnToNPM(_m, command);
+    return npmCommand.replace(/npm(?: +([^&\n\r]*))?/gm, npmToBun);
+}
+function pnpmToBun() {
+    return 'pnpm to bun';
+}
+
+/**
+ * Returns the current package manager
+ */
+function getManager(command) {
+    if (command.startsWith('yarn')) {
+        return 'yarn';
+    }
+    else if (command.startsWith('pnpm')) {
+        return 'pnpm';
+    }
+    else if (command.startsWith('bun')) {
+        return 'bun';
+    }
+    return 'npm';
+}
+/**
+ * Checks whether the command is other than npm command
+ */
+function isOtherManagerCommand(command) {
+    var currentManager = getManager(command);
+    return currentManager !== 'npm';
+}
 
 /**
  * Converts between npm and yarn command
  */
 function convert(str, to) {
     if (to === 'npm') {
+        // pnpm | bun to npm
+        if (isOtherManagerCommand(str)) {
+            var manager = getManager(str);
+            if (manager === 'pnpm') {
+                return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToNpm);
+            }
+            else if (manager === 'bun') {
+                return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToNpm);
+            }
+        }
+        // yarn to npm
         return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToNPM);
     }
     else if (to === 'pnpm') {
+        // yarn | bun to pnpm
+        if (isOtherManagerCommand(str)) {
+            var manager = getManager(str);
+            if (manager === 'yarn') {
+                return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToPnpm);
+            }
+            else if (manager === 'bun') {
+                return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToPnpm);
+            }
+        }
+        // npm to pnpm
         return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToPnpm);
     }
     else if (to === 'bun') {
+        // yarn | pnpm to bun
+        if (isOtherManagerCommand(str)) {
+            var manager = getManager(str);
+            if (manager === 'yarn') {
+                return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToBun);
+            }
+            else if (manager === 'pnpm') {
+                return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToBun);
+            }
+        }
+        // npm to bun
         return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToBun);
     }
     else {
+        // pnpm | bun to yarn
+        if (isOtherManagerCommand(str)) {
+            var manager = getManager(str);
+            if (manager === 'pnpm') {
+                return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToYarn);
+            }
+            else if (manager === 'bun') {
+                return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToYarn);
+            }
+        }
+        // npm to yarn
         return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToYarn);
     }
 }

dist/types/lib.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the current package manager
+ */
+export declare function getManager(command: string): 'npm' | 'yarn' | 'pnpm' | 'bun';
+/**
+ * Checks whether the command is other than npm command
+ */
+export declare function isOtherManagerCommand(command: string): boolean;

dist/types/toBun.d.ts

@@ -0,0 +1,4 @@
+export declare const bunCLICommands: readonly ["init", "run", "add", "pm", "help", "install", "remove", "upgrade", "version"];
+export declare function npmToBun(_m: string, command: string): string;
+export declare function yarnToBun(_m: string, command: string): string;
+export declare function pnpmToBun(): string;

dist/types/toNpm.d.ts

@@ -0,0 +1,3 @@
+export declare function yarnToNPM(_m: string, command: string): string;
+export declare function pnpmToNpm(): string;
+export declare function bunToNpm(): string;

dist/types/toPnpm.d.ts

@@ -0,0 +1,3 @@
+export declare function npmToPnpm(_m: string, command: string): string;
+export declare function yarnToPnpm(_m: string, command: string): string;
+export declare function bunToPnpm(): string;

dist/types/toYarn.d.ts

@@ -0,0 +1,3 @@
+export declare function npmToYarn(_m: string, command: string): string;
+export declare function pnpmToYarn(): string;
+export declare function bunToYarn(): string;

jest.config.js

@@ -9,7 +9,7 @@ module.exports = {
   testEnvironment: 'node',
   testRegex: '(/test/.*|\\.(test|spec))\\.(ts|js)$',
   moduleFileExtensions: ['ts', 'js'],
-  coveragePathIgnorePatterns: ['/node_modules/', '/test/'],
+  coveragePathIgnorePatterns: ['/node_modules/', '/test/', 'src/lib.ts'],
   coverageThreshold: {
     global: {
       branches: 80,

src/index.ts

@@ -1,19 +1,69 @@
-import { yarnToNPM } from './yarnToNpm'
-import { npmToYarn } from './npmToYarn'
-import { npmToPnpm } from './npmToPnpm'
-import { npmToBun } from './npmToBun'
+import { yarnToNPM, pnpmToNpm, bunToNpm } from './toNpm'
+import { npmToYarn, pnpmToYarn, bunToYarn } from './toYarn'
+import { npmToPnpm, yarnToPnpm, bunToPnpm } from './toPnpm'
+import { npmToBun, yarnToBun, pnpmToBun } from './toBun'
+
+import { getManager, isOtherManagerCommand } from './lib'
 
 /**
  * Converts between npm and yarn command
  */
 export default function convert (str: string, to: 'npm' | 'yarn' | 'pnpm' | 'bun'): string {
   if (to === 'npm') {
+
+    // pnpm | bun to npm
+    if (isOtherManagerCommand(str)) {
+      const manager = getManager(str)
+      if (manager === 'pnpm') {
+        return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToNpm)
+      } else if (manager === 'bun') {
+        return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToNpm)
+      }
+    }
+
+    // yarn to npm
     return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToNPM)
   } else if (to === 'pnpm') {
+
+    // yarn | bun to pnpm
+    if (isOtherManagerCommand(str)) {
+      const manager = getManager(str)
+      if (manager === 'yarn') {
+        return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToPnpm)
+      } else if (manager === 'bun') {
+        return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToPnpm)
+      }
+    }
+
+    // npm to pnpm
     return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToPnpm)
   } else if (to === 'bun') {
+
+    // yarn | pnpm to bun
+    if (isOtherManagerCommand(str)) {
+      const manager = getManager(str)
+      if (manager === 'yarn') {
+        return str.replace(/yarn(?: +([^&\n\r]*))?/gm, yarnToBun)
+      } else if (manager === 'pnpm') {
+        return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToBun)
+      }
+    }
+
+    // npm to bun
     return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToBun)
   } else {
+
+    // pnpm | bun to yarn
+    if (isOtherManagerCommand(str)) {
+      const manager = getManager(str)
+      if (manager === 'pnpm') {
+        return str.replace(/pnpm(?: +([^&\n\r]*))?/gm, pnpmToYarn)
+      } else if (manager === 'bun') {
+        return str.replace(/bun(?: +([^&\n\r]*))?/gm, bunToYarn)
+      }
+    }
+
+    // npm to yarn
     return str.replace(/npm(?: +([^&\n\r]*))?/gm, npmToYarn)
   }
 }