refactor: remove hasYarn function and rename spawn

packages/api/cli/package.json

@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "@electron-forge/core": "7.6.1",
+    "@electron-forge/core-utils": "7.6.1",
     "@electron-forge/shared-types": "7.6.1",
     "@electron/get": "^3.0.0",
     "chalk": "^4.0.0",

packages/api/cli/src/util/check-system.ts

@@ -2,7 +2,7 @@ import { exec } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
 
-import { utils as forgeUtils } from '@electron-forge/core';
+import { resolvePackageManager, spawnPackageManager } from '@electron-forge/core-utils';
 import { ForgeListrTask } from '@electron-forge/shared-types';
 import debug from 'debug';
 import fs from 'fs-extra';
@@ -55,9 +55,9 @@ function warnIfPackageManagerIsntAKnownGoodVersion(packageManager: string, versi
 }
 
 async function checkPackageManagerVersion() {
-  const version = await forgeUtils.yarnOrNpmSpawn(['--version']);
+  const version = await spawnPackageManager(['--version']);
   const versionString = version.toString().trim();
-  if (await forgeUtils.hasYarn()) {
+  if ((await resolvePackageManager()) === 'yarn') {
     warnIfPackageManagerIsntAKnownGoodVersion('Yarn', versionString, YARN_ALLOWLISTED_VERSIONS);
     return `yarn@${versionString}`;
   } else {

packages/api/core/spec/fast/util/install-dependencies.spec.ts

@@ -1,4 +1,4 @@
-import { hasYarn, yarnOrNpmSpawn } from '@electron-forge/core-utils';
+import { resolvePackageManager, spawnPackageManager } from '@electron-forge/core-utils';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import installDependencies, { DepType, DepVersionRestriction } from '../../../src/util/install-dependencies';
@@ -7,53 +7,53 @@ vi.mock(import('@electron-forge/core-utils'), async (importOriginal) => {
   const mod = await importOriginal();
   return {
     ...mod,
-    hasYarn: vi.fn(),
-    yarnOrNpmSpawn: vi.fn(),
+    resolvePackageManager: vi.fn(),
+    spawnPackageManager: vi.fn(),
   };
 });
 
 describe('installDependencies', () => {
   it('should immediately resolve if no deps are provided', async () => {
     await installDependencies('mydir', []);
-    expect(yarnOrNpmSpawn).not.toHaveBeenCalled();
+    expect(spawnPackageManager).not.toHaveBeenCalled();
   });
 
   it('should reject if reject the promise if exit code is not 0', async () => {
-    vi.mocked(yarnOrNpmSpawn).mockRejectedValueOnce('fail');
+    vi.mocked(spawnPackageManager).mockRejectedValueOnce('fail');
     await expect(installDependencies('void', ['electron'])).rejects.toThrow('fail');
   });
 
   it('should resolve if reject the promise if exit code is 0', async () => {
-    vi.mocked(yarnOrNpmSpawn).mockResolvedValueOnce('pass');
+    vi.mocked(spawnPackageManager).mockResolvedValueOnce('pass');
     await expect(installDependencies('void', ['electron'])).resolves.toBe(undefined);
   });
 
   describe.each([
-    { pm: 'npm', install: 'install', flags: { exact: '--save-exact', dev: '--save-dev' } },
-    { pm: 'yarn', install: 'add', flags: { exact: '--exact', dev: '--dev' } },
+    { pm: 'npm' as const, install: 'install', flags: { exact: '--save-exact', dev: '--save-dev' } },
+    { pm: 'yarn' as const, install: 'add', flags: { exact: '--exact', dev: '--dev' } },
   ])('$pm', ({ pm, install, flags }) => {
     beforeEach(() => {
-      vi.mocked(hasYarn).mockResolvedValue(pm === 'yarn');
+      vi.mocked(resolvePackageManager).mockResolvedValue(pm);
     });
 
     it('should install deps', async () => {
       await installDependencies('mydir', ['react']);
-      expect(yarnOrNpmSpawn).toHaveBeenCalledWith([install, 'react'], expect.anything());
+      expect(spawnPackageManager).toHaveBeenCalledWith([install, 'react'], expect.anything());
     });
 
     it('should install dev deps', async () => {
       await installDependencies('mydir', ['eslint'], DepType.DEV);
-      expect(yarnOrNpmSpawn).toHaveBeenCalledWith([install, 'eslint', flags.dev], expect.anything());
+      expect(spawnPackageManager).toHaveBeenCalledWith([install, 'eslint', flags.dev], expect.anything());
     });
 
     it('should install exact deps', async () => {
       await installDependencies('mydir', ['react'], DepType.PROD, DepVersionRestriction.EXACT);
-      expect(yarnOrNpmSpawn).toHaveBeenCalledWith([install, 'react', flags.exact], expect.anything());
+      expect(spawnPackageManager).toHaveBeenCalledWith([install, 'react', flags.exact], expect.anything());
     });
 
     it('should install exact dev deps', async () => {
       await installDependencies('mydir', ['eslint'], DepType.DEV, DepVersionRestriction.EXACT);
-      expect(yarnOrNpmSpawn).toHaveBeenCalledWith([install, 'eslint', flags.dev, flags.exact], expect.anything());
+      expect(spawnPackageManager).toHaveBeenCalledWith([install, 'eslint', flags.dev, flags.exact], expect.anything());
     });
   });
 });

packages/api/core/src/api/import.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 
-import { safeYarnOrNpm, updateElectronDependency } from '@electron-forge/core-utils';
+import { resolvePackageManager, updateElectronDependency } from '@electron-forge/core-utils';
 import { ForgeListrOptions, ForgeListrTaskFn } from '@electron-forge/shared-types';
 import baseTemplate from '@electron-forge/template-base';
 import { autoTrace } from '@electron-forge/tracer';
@@ -193,7 +193,7 @@ export default autoTrace(
                 {
                   title: 'Installing dependencies',
                   task: async (_, task) => {
-                    const packageManager = await safeYarnOrNpm();
+                    const packageManager = await resolvePackageManager();
                     await writeChanges();
 
                     d('deleting old dependencies forcefully');

packages/api/core/src/api/init-scripts/init-link.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 
-import { safeYarnOrNpm, yarnOrNpmSpawn } from '@electron-forge/core-utils';
+import { resolvePackageManager, spawnPackageManager } from '@electron-forge/core-utils';
 import { ForgeListrTask } from '@electron-forge/shared-types';
 import debug from 'debug';
 
@@ -22,12 +22,12 @@ export async function initLink<T>(dir: string, task?: ForgeListrTask<T>) {
   if (shouldLink) {
     d('Linking forge dependencies');
     const packageJson = await readRawPackageJson(dir);
-    const packageManager = await safeYarnOrNpm();
+    const packageManager = await resolvePackageManager();
     const linkFolder = path.resolve(__dirname, '..', '..', '..', '..', '..', '..', '.links');
     for (const packageName of Object.keys(packageJson.devDependencies)) {
       if (packageName.startsWith('@electron-forge/')) {
         if (task) task.output = `${packageManager} link --link-folder ${linkFolder} ${packageName}`;
-        await yarnOrNpmSpawn(['link', '--link-folder', linkFolder, packageName], {
+        await spawnPackageManager(['link', '--link-folder', linkFolder, packageName], {
           cwd: dir,
         });
       }

packages/api/core/src/api/init-scripts/init-npm.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 
-import { safeYarnOrNpm } from '@electron-forge/core-utils';
+import { resolvePackageManager } from '@electron-forge/core-utils';
 import { ForgeListrTask } from '@electron-forge/shared-types';
 import debug from 'debug';
 import fs from 'fs-extra';
@@ -29,7 +29,7 @@ export const exactDevDeps = ['electron'];
 
 export const initNPM = async <T>(dir: string, task: ForgeListrTask<T>): Promise<void> => {
   d('installing dependencies');
-  const packageManager = await safeYarnOrNpm();
+  const packageManager = await resolvePackageManager();
   task.output = `${packageManager} install ${deps.join(' ')}`;
   await installDepList(dir, deps);
 

packages/api/core/src/api/init.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 
-import { safeYarnOrNpm } from '@electron-forge/core-utils';
+import { resolvePackageManager } from '@electron-forge/core-utils';
 import { ForgeTemplate } from '@electron-forge/shared-types';
 import debug from 'debug';
 import { Listr } from 'listr2';
@@ -56,7 +56,7 @@ async function validateTemplate(template: string, templateModule: ForgeTemplate)
 export default async ({ dir = process.cwd(), interactive = false, copyCIFiles = false, force = false, template = 'base' }: InitOptions): Promise<void> => {
   d(`Initializing in: ${dir}`);
 
-  const packageManager = await safeYarnOrNpm();
+  const packageManager = await resolvePackageManager();
 
   const runner = new Listr<{
     templateModule: ForgeTemplate;

packages/api/core/src/util/index.ts

@@ -1,4 +1,4 @@
-import { getElectronVersion, hasYarn, yarnOrNpmSpawn } from '@electron-forge/core-utils';
+import { getElectronVersion, spawnPackageManager } from '@electron-forge/core-utils';
 
 import {
   BuildIdentifierConfig,
@@ -24,9 +24,7 @@ export default class ForgeUtils {
 
   getElectronVersion = getElectronVersion;
 
-  hasYarn = hasYarn;
-
-  yarnOrNpmSpawn = yarnOrNpmSpawn;
+  spawnPackageManager = spawnPackageManager;
 
   /**
    * Register a virtual config file for forge to find.

packages/api/core/src/util/install-dependencies.ts

@@ -1,4 +1,4 @@
-import { hasYarn, yarnOrNpmSpawn } from '@electron-forge/core-utils';
+import { resolvePackageManager, spawnPackageManager } from '@electron-forge/core-utils';
 import { ExitError } from '@malept/cross-spawn-promise';
 import debug from 'debug';
 
@@ -15,13 +15,14 @@ export enum DepVersionRestriction {
 }
 
 export default async (dir: string, deps: string[], depType = DepType.PROD, versionRestriction = DepVersionRestriction.RANGE): Promise<void> => {
-  d('installing', JSON.stringify(deps), 'in:', dir, `depType=${depType},versionRestriction=${versionRestriction},withYarn=${await hasYarn()}`);
+  const pm = await resolvePackageManager();
+  d('installing', JSON.stringify(deps), 'in:', dir, `depType=${depType},versionRestriction=${versionRestriction},withPackageManager=${pm}`);
   if (deps.length === 0) {
     d('nothing to install, stopping immediately');
     return Promise.resolve();
   }
   let cmd = ['install'].concat(deps);
-  if (await hasYarn()) {
+  if (pm === 'yarn') {
     cmd = ['add'].concat(deps);
     if (depType === DepType.DEV) cmd.push('--dev');
     if (versionRestriction === DepVersionRestriction.EXACT) cmd.push('--exact');
@@ -31,7 +32,7 @@ export default async (dir: string, deps: string[], depType = DepType.PROD, versi
   }
   d('executing', JSON.stringify(cmd), 'in:', dir);
   try {
-    await yarnOrNpmSpawn(cmd, {
+    await spawnPackageManager(cmd, {
       cwd: dir,
       stdio: 'pipe',
     });

packages/utils/core-utils/spec/package-manager.spec.ts

@@ -1,7 +1,7 @@
 import { detect } from 'detect-package-manager';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { safeYarnOrNpm } from '../src/package-manager';
+import { resolvePackageManager } from '../src/package-manager';
 
 describe('package-manager', () => {
   let nodeInstaller: string | undefined;
@@ -21,24 +21,24 @@ describe('package-manager', () => {
 
   it('should by default equal the system package manager value', async () => {
     const pm = await detect();
-    await expect(safeYarnOrNpm()).resolves.toEqual(pm);
+    await expect(resolvePackageManager()).resolves.toEqual(pm);
   });
 
   it('should return yarn if NODE_INSTALLER=yarn', async () => {
     process.env.NODE_INSTALLER = 'yarn';
-    await expect(safeYarnOrNpm()).resolves.toEqual('yarn');
+    await expect(resolvePackageManager()).resolves.toEqual('yarn');
   });
 
   it('should return npm if NODE_INSTALLER=npm', async () => {
     process.env.NODE_INSTALLER = 'npm';
-    await expect(safeYarnOrNpm()).resolves.toEqual('npm');
+    await expect(resolvePackageManager()).resolves.toEqual('npm');
   });
 
   it('should return system value if NODE_INSTALLER is an unrecognized installer', async () => {
     process.env.NODE_INSTALLER = 'magical_unicorn';
     console.warn = vi.fn();
     const pm = await detect();
-    await expect(safeYarnOrNpm()).resolves.toEqual(pm);
+    await expect(resolvePackageManager()).resolves.toEqual(pm);
     expect(console.warn).toHaveBeenCalledWith('⚠', expect.stringContaining('Unknown NODE_INSTALLER'));
   });
 });

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

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import { detect } from 'detect-package-manager';
 import logSymbols from 'log-symbols';
 
-export const safeYarnOrNpm = async () => {
+export const resolvePackageManager = async () => {
   const system = await detect();
   switch (process.env.NODE_INSTALLER) {
     case 'yarn':
@@ -17,6 +17,4 @@ export const safeYarnOrNpm = async () => {
   }
 };
 
-export const yarnOrNpmSpawn = async (args?: CrossSpawnArgs, opts?: CrossSpawnOptions): Promise<string> => spawn(await safeYarnOrNpm(), args, opts);
-
-export const hasYarn = async () => (await safeYarnOrNpm()) === 'yarn';
+export const spawnPackageManager = async (args?: CrossSpawnArgs, opts?: CrossSpawnOptions): Promise<string> => spawn(await resolvePackageManager(), args, opts);