@form8ion/javascript 15.5.0 → 15.6.1

package/src/package/scaffolder.js

@@ -0,0 +1,32 @@
+import {info} from '@travi/cli-messages';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import buildPackageName from './package-name.js';
+import buildPackageDetails from './details.js';
+
+export default async function scaffoldPackage({
+  projectRoot,
+  projectName,
+  scope,
+  dialect,
+  license,
+  author,
+  description
+}) {
+  info('Configuring package.json');
+
+  const packageName = buildPackageName(projectName, scope);
+
+  await writePackageJson({
+    projectRoot,
+    config: await buildPackageDetails({
+      packageName,
+      dialect,
+      license,
+      author,
+      description
+    })
+  });
+
+  return {packageName};
+}

package/src/package/scaffolder.test.js

@@ -0,0 +1,46 @@
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import * as buildPackageDetails from './details.js';
+import buildPackageName from './package-name.js';
+import {scaffold} from './index.js';
+
+vi.mock('@form8ion/javascript-core');
+vi.mock('./package-name.js');
+vi.mock('./details.js');
+
+describe('package scaffolder', () => {
+  it('should create the package file', async () => {
+    const projectName = any.string();
+    const packageName = any.string();
+    const scope = any.word();
+    const packageDetails = any.simpleObject();
+    const projectRoot = any.string();
+    const dialect = any.word();
+    const license = any.string();
+    const author = any.simpleObject();
+    const description = any.sentence();
+    when(buildPackageName).calledWith(projectName, scope).thenReturn(packageName);
+    when(buildPackageDetails.default).calledWith({
+      packageName,
+      dialect,
+      license,
+      author,
+      description
+    }).thenResolve(packageDetails);
+
+    expect(await scaffold({
+      projectRoot,
+      projectName,
+      scope,
+      dialect,
+      license,
+      author,
+      description
+    })).toEqual({packageName});
+    expect(writePackageJson).toHaveBeenCalledWith({projectRoot, config: packageDetails});
+  });
+});

package/src/package/scripts/index.js

@@ -0,0 +1 @@
+export {default as lift} from './lifter.js';

package/src/package/scripts/lifter.js

@@ -0,0 +1,14 @@
+import updateTestScript from './test-script-updater.js';
+import sortScripts from './scripts-sorter.js';
+
+export default function liftScripts({existingScripts, scripts}) {
+  return {
+    scripts: sortScripts(updateTestScript({...existingScripts, ...scripts})),
+    dependencies: {
+      javascript: {
+        development: ['npm-run-all2'],
+        remove: ['npm-run-all']
+      }
+    }
+  };
+}

package/src/package/scripts/lifter.test.js

@@ -0,0 +1,31 @@
+import any from '@travi/any';
+import {when} from 'vitest-when';
+import {describe, expect, it, vi} from 'vitest';
+
+import updateTestScript from './test-script-updater.js';
+import sortScripts from './scripts-sorter.js';
+import liftScripts from './lifter.js';
+
+vi.mock('./scripts-sorter.js');
+vi.mock('./test-script-updater.js');
+
+describe('package.json scripts lifter', () => {
+  it('should merge the provided scripts with the existing scripts', () => {
+    const existingScripts = any.simpleObject();
+    const scripts = any.simpleObject();
+    const updatedScripts = any.simpleObject();
+    const sortedScripts = any.simpleObject();
+    when(updateTestScript).calledWith({...existingScripts, ...scripts}).thenReturn(updatedScripts);
+    when(sortScripts).calledWith(updatedScripts).thenReturn(sortedScripts);
+
+    expect(liftScripts({existingScripts, scripts})).toEqual({
+      scripts: sortedScripts,
+      dependencies: {
+        javascript: {
+          development: ['npm-run-all2'],
+          remove: ['npm-run-all']
+        }
+      }
+    });
+  });
+});

package/src/package/scripts/script-comparator.js

@@ -0,0 +1,46 @@
+function isRelatedScript(a, b, prefix) {
+  return a.startsWith(prefix) && a.slice(prefix.length) === b;
+}
+
+function isPreScriptFor(a, b) {
+  return isRelatedScript(a, b, 'pre');
+}
+
+function isPostScriptFor(a, b) {
+  return isRelatedScript(a, b, 'post');
+}
+
+function stripPrefix(script) {
+  if (script.startsWith('pre')) return script.slice(3);
+  if (script.startsWith('post')) return script.slice(4);
+  return script;
+}
+
+function getCategoryOrder(script) {
+  const base = stripPrefix(script);
+  if ('test' === base) return 0;
+  if (base.startsWith('lint:')) return 1;
+  if (base.startsWith('test:unit')) return 2;
+  if (base.startsWith('test:integration')) return 3;
+  if (base.startsWith('test:')) return 2;
+
+  return 4;
+}
+
+export default function compareScriptNames(a, b) {
+  if (isPreScriptFor(a, b)) return -1;
+  if (isPreScriptFor(b, a)) return 1;
+  if (isPostScriptFor(a, b)) return 1;
+  if (isPostScriptFor(b, a)) return -1;
+
+  const categoryDiff = getCategoryOrder(a) - getCategoryOrder(b);
+  if (0 !== categoryDiff) return 0 > categoryDiff ? -1 : 1;
+
+  const aStripped = stripPrefix(a);
+  const bStripped = stripPrefix(b);
+
+  const aKey = aStripped !== a ? aStripped : a;
+  const bKey = bStripped !== b ? bStripped : b;
+
+  return aKey.localeCompare(bKey);
+}

package/src/package/scripts/script-comparator.test.js

@@ -0,0 +1,119 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import compareScriptNames from './script-comparator.js';
+
+describe('script name comparator', () => {
+  const A_AFTER_B = 1;
+  const A_BEFORE_B = -1;
+  const baseScriptName = any.word();
+
+  it('should sort alphabetically if no other rules apply', async () => {
+    const a = `a${any.word()}`;
+    const b = `b${any.word()}`;
+
+    expect(compareScriptNames(a, b)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(b, a)).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `pre` scripts ahead of their related scripts', async () => {
+    expect(compareScriptNames(`pre${baseScriptName}`, baseScriptName)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(baseScriptName, `pre${baseScriptName}`)).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames('pretest', 'test')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('test', 'pretest')).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames('prelint:publish', 'lint:publish')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('lint:publish', 'prelint:publish')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort a `pre` script directly before its base script relative to unrelated scripts', async () => {
+    const baseName = `b${any.word()}`;
+    const scriptBetween = `c${any.word()}`;
+
+    expect(compareScriptNames(`pre${baseName}`, scriptBetween)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(scriptBetween, `pre${baseName}`)).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `post` scripts after of their related scripts', async () => {
+    expect(compareScriptNames(`post${baseScriptName}`, baseScriptName)).toEqual(A_AFTER_B);
+    expect(compareScriptNames(baseScriptName, `post${baseScriptName}`)).toEqual(A_BEFORE_B);
+
+    expect(compareScriptNames('posttest', 'test')).toEqual(A_AFTER_B);
+    expect(compareScriptNames('test', 'posttest')).toEqual(A_BEFORE_B);
+
+    expect(compareScriptNames(`postlint:${any.word()}`, `test:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`test:${any.word()}`, `postlint:${any.word()}`)).toEqual(A_AFTER_B);
+  });
+
+  it('should sort the `test` script ahead of any sub-test scripts', async () => {
+    expect(compareScriptNames('test', `test:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`test:${any.word()}`, 'test')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `lint:` scripts above `test:` scripts', async () => {
+    expect(compareScriptNames(`lint:${any.word()}`, `test:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`test:${any.word()}`, `lint:${any.word()}`)).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames(`prelint:${any.word()}`, `test:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`test:${any.word()}`, `prelint:${any.word()}`)).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames(`lint:${any.word()}`, `pretest:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`pretest:${any.word()}`, `lint:${any.word()}`)).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames(`prelint:${any.word()}`, `pretest:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`pretest:${any.word()}`, `prelint:${any.word()}`)).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `pretest` ahead of `lint:` scripts', async () => {
+    expect(compareScriptNames('pretest', `lint:${any.word()}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`lint:${any.word()}`, 'pretest')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort subscripts alphabetically', async () => {
+    const a = `a${any.word()}`;
+    const b = `b${any.word()}`;
+
+    expect(compareScriptNames(`lint:${a}`, `lint:${b}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`lint:${b}`, `lint:${a}`)).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames(`test:${a}`, `test:${b}`)).toEqual(A_BEFORE_B);
+    expect(compareScriptNames(`test:${b}`, `test:${a}`)).toEqual(A_AFTER_B);
+  });
+
+  it('should sort undefined scripts below `lint:` scripts', async () => {
+    expect(compareScriptNames(any.word(), `lint:${any.word()}`)).toEqual(A_AFTER_B);
+    expect(compareScriptNames(`lint:${any.word()}`, any.word())).toEqual(A_BEFORE_B);
+  });
+
+  it('should sort `test:unit` ahead of `test:integration`', async () => {
+    expect(compareScriptNames('test:unit', 'test:integration')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('test:integration', 'test:unit')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `test:unit` sub-scripts after `test:unit`', async () => {
+    expect(compareScriptNames('test:unit', 'test:unit:base')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('test:unit:base', 'test:unit')).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames('test:unit', 'pretest:unit:base')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('pretest:unit:base', 'test:unit')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `test:integration` sub-scripts after `test:integration`', async () => {
+    expect(compareScriptNames('test:integration', 'test:integration:base')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('test:integration:base', 'test:integration')).toEqual(A_AFTER_B);
+
+    expect(compareScriptNames('test:integration', 'pretest:integration:base')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('pretest:integration:base', 'test:integration')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort `test:unit` sub-scripts ahead of `test:integration`', async () => {
+    expect(compareScriptNames('test:unit:base', 'test:integration')).toEqual(A_BEFORE_B);
+    expect(compareScriptNames('test:integration', 'test:unit:base')).toEqual(A_AFTER_B);
+  });
+
+  it('should sort uncategorized scripts below `test:` scripts', async () => {
+    expect(compareScriptNames(any.word(), `test:${any.word()}`)).toEqual(A_AFTER_B);
+    expect(compareScriptNames(`test:${any.word()}`, any.word())).toEqual(A_BEFORE_B);
+  });
+});

package/src/package/scripts/scripts-sorter.js

@@ -0,0 +1,7 @@
+import sortObjectKeys from 'sort-object-keys';
+
+import compareScriptNames from './script-comparator.js';
+
+export default function sortScripts(scripts) {
+  return sortObjectKeys(scripts, compareScriptNames);
+}

package/src/package/scripts/scripts-sorter.test.js

@@ -0,0 +1,20 @@
+import sortObjectKeys from 'sort-object-keys';
+
+import {it, describe, expect, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import compareScriptNames from './script-comparator.js';
+import sortScripts from './scripts-sorter.js';
+
+vi.mock('sort-object-keys');
+
+describe('npm scripts sorter', () => {
+  it('should sort the scripts based on the defined order', async () => {
+    const unsortedScripts = any.simpleObject();
+    const sortedScripts = any.simpleObject();
+    when(sortObjectKeys).calledWith(unsortedScripts, compareScriptNames).thenReturn(sortedScripts);
+
+    expect(sortScripts(unsortedScripts)).toEqual(sortedScripts);
+  });
+});

package/src/package/scripts/test-script-updater.js

@@ -0,0 +1,15 @@
+function projectWillBeTested(scripts) {
+  return Object.keys(scripts).find(scriptName => scriptName.startsWith('test:'));
+}
+
+function projectShouldBeBuiltForVerification(scripts) {
+  return 'run-s build' === scripts['pregenerate:md'];
+}
+
+export default function updateTestScript(scripts) {
+  return {
+    ...scripts,
+    ...projectShouldBeBuiltForVerification(scripts) && {pretest: 'run-s build'},
+    test: `npm-run-all --print-label --parallel lint:*${projectWillBeTested(scripts) ? ' --parallel test:*' : ''}`
+  };
+}

package/src/package/scripts/test-script-updater.test.js

@@ -0,0 +1,32 @@
+import any from '@travi/any';
+import {describe, expect, it} from 'vitest';
+
+import updateTestScript from './test-script-updater.js';
+
+describe('test script updater', () => {
+  const scripts = {...any.simpleObject(), test: any.string(), [`lint:${any.word()}`]: any.string()};
+
+  it('should define the `test` script', () => {
+    expect(updateTestScript(scripts)).toEqual({...scripts, test: 'npm-run-all --print-label --parallel lint:*'});
+  });
+
+  it('should include a build step in the `test` script if a generate script for markdown is included', () => {
+    expect(updateTestScript({...scripts, 'pregenerate:md': 'run-s build'})).toEqual({
+      ...scripts,
+      'pregenerate:md': 'run-s build',
+      pretest: 'run-s build',
+      test: 'npm-run-all --print-label --parallel lint:*'
+    });
+  });
+
+  it('should include running tests in the `test` script when the project will be tested', () => {
+    const testScriptName = `test:${any.word()}`;
+    const testScriptValue = any.string();
+
+    expect(updateTestScript({...scripts, [testScriptName]: testScriptValue})).toEqual({
+      ...scripts,
+      [testScriptName]: testScriptValue,
+      test: 'npm-run-all --print-label --parallel lint:* --parallel test:*'
+    });
+  });
+});

package/src/package/vcs-host-details.js

@@ -0,0 +1,12 @@
+export default function scaffoldVcsHostDetails(vcs, pathWithinParent) {
+  return vcs && 'github' === vcs.host && {
+    repository: pathWithinParent
+      ? {
+        type: 'git',
+        url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
+        directory: pathWithinParent
+      }
+      : `${vcs.owner}/${vcs.name}`,
+    bugs: `https://github.com/${vcs.owner}/${vcs.name}/issues`
+  };
+}

package/src/package/vcs-host-details.test.js

@@ -0,0 +1,16 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import defineVcsHostDetails from './vcs-host-details.js';
+
+describe('vcs host details', () => {
+  it('should define the repository details when the host is github', () => {
+    const owner = any.word();
+    const name = any.word();
+
+    expect(defineVcsHostDetails({host: 'github', owner, name})).toEqual({
+      repository: `${owner}/${name}`,
+      bugs: `https://github.com/${owner}/${name}/issues`
+    });
+  });
+});

package/src/package-managers/current-manager-resolver.js

@@ -0,0 +1,21 @@
+import {promises as fs} from 'node:fs';
+import {packageManagers} from '@form8ion/javascript-core';
+
+import {test as npmIsUsed} from './npm/index.js';
+import {test as yarnIsUsed} from './yarn/index.js';
+
+export default async function resolveCurrentPackageManager({projectRoot, packageManager}) {
+  if (packageManager) return packageManager;
+
+  const {packageManager: pinnedPackageManager} = JSON.parse(await fs.readFile(`${projectRoot}/package.json`, 'utf-8'));
+
+  if (await npmIsUsed({projectRoot, pinnedPackageManager})) {
+    return packageManagers.NPM;
+  }
+
+  if (await yarnIsUsed({projectRoot, pinnedPackageManager})) {
+    return packageManagers.YARN;
+  }
+
+  throw new Error('Package-manager could not be determined');
+}

package/src/package-managers/current-manager-resolver.test.js

@@ -0,0 +1,51 @@
+import {promises as fs} from 'node:fs';
+import {packageManagers} from '@form8ion/javascript-core';
+
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {test as npmIsUsed} from './npm/index.js';
+import {test as yarnIsUsed} from './yarn/index.js';
+import derive from './current-manager-resolver.js';
+
+vi.mock('node:fs');
+vi.mock('./npm/index.js');
+vi.mock('./yarn/index.js');
+
+describe('package manager', () => {
+  const projectRoot = any.string();
+  const pinnedPackageManager = any.word();
+
+  beforeEach(() => {
+    when(fs.readFile)
+      .calledWith(`${projectRoot}/package.json`, 'utf-8')
+      .thenResolve(JSON.stringify({...any.simpleObject(), packageManager: pinnedPackageManager}));
+  });
+
+  it('should return an already defined manager directly', async () => {
+    const packageManager = any.word();
+
+    expect(await derive({packageManager})).toEqual(packageManager);
+  });
+
+  it('should return `npm` when a `package-lock.json` exists', async () => {
+    when(npmIsUsed).calledWith({projectRoot, pinnedPackageManager}).thenResolve(true);
+
+    expect(await derive({projectRoot})).toEqual(packageManagers.NPM);
+  });
+
+  it('should return `yarn` when a `yarn.lock` exists', async () => {
+    when(npmIsUsed).calledWith({projectRoot, pinnedPackageManager}).thenResolve(false);
+    when(yarnIsUsed).calledWith({projectRoot, pinnedPackageManager}).thenResolve(true);
+
+    expect(await derive({projectRoot})).toEqual(packageManagers.YARN);
+  });
+
+  it('should throw an error when no manager is provided and no lockfile is found', async () => {
+    when(npmIsUsed).calledWith({projectRoot, pinnedPackageManager}).thenResolve(false);
+    when(yarnIsUsed).calledWith({projectRoot, pinnedPackageManager}).thenResolve(false);
+
+    await expect(() => derive({projectRoot})).rejects.toThrowError('Package-manager could not be determined');
+  });
+});

package/src/package-managers/index.js

@@ -0,0 +1,5 @@
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';
+export {default as scaffold} from './scaffolder.js';
+export {default as determineCurrent} from './current-manager-resolver.js';
+export {default as defineLockfilePath} from './lockfile-path-resolver.js';

package/src/package-managers/lifter.js

@@ -0,0 +1,7 @@
+import {lift as liftCorepack} from '../corepack/index.js';
+
+export default async function liftPackageManagers() {
+  await liftCorepack();
+
+  return {};
+}

package/src/package-managers/lifter.test.js

@@ -0,0 +1,18 @@
+import {describe, it, vi, expect, afterEach} from 'vitest';
+
+import {lift as liftCorepack} from '../corepack/index.js';
+import liftPackageManger from './lifter.js';
+
+vi.mock('../corepack/index.js');
+
+describe('package-manager lifter', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should lift package-manager details', async () => {
+    expect(await liftPackageManger()).toEqual({});
+
+    expect(liftCorepack).toHaveBeenCalled();
+  });
+});

package/src/package-managers/lockfile-path-resolver.js

@@ -0,0 +1,10 @@
+import {packageManagers} from '@form8ion/javascript-core';
+
+export default function resolveLockfilePath(packageManager) {
+  const lockfilePaths = {
+    [packageManagers.NPM]: 'package-lock.json',
+    [packageManagers.YARN]: 'yarn.lock'
+  };
+
+  return lockfilePaths[packageManager];
+}

package/src/package-managers/lockfile-path-resolver.test.js

@@ -0,0 +1,15 @@
+import {packageManagers} from '@form8ion/javascript-core';
+
+import {describe, it, expect} from 'vitest';
+
+import determineLockfilePathFor from './lockfile-path-resolver.js';
+
+describe('package manager lockfile path resolver', () => {
+  it('should return `package-lock.json` for npm', () => {
+    expect(determineLockfilePathFor(packageManagers.NPM)).toEqual('package-lock.json');
+  });
+
+  it('should return `yarn.lock` for yarn', () => {
+    expect(determineLockfilePathFor(packageManagers.YARN)).toEqual('yarn.lock');
+  });
+});

package/src/package-managers/npm/index.js

@@ -0,0 +1,2 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';

package/src/package-managers/npm/scaffolder.js

@@ -0,0 +1,19 @@
+import {promises as fs} from 'node:fs';
+import {execa} from 'execa';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+export default async function scaffoldNpmPackageManager({projectRoot}) {
+  const [packageContents, {stdout}] = await Promise.all([
+    fs.readFile(`${projectRoot}/package.json`, 'utf-8'),
+    execa('npm', ['--version'])
+  ]);
+  const existingPackageJsonContents = JSON.parse(packageContents);
+
+  await writePackageJson({
+    projectRoot,
+    config: {
+      ...existingPackageJsonContents,
+      packageManager: `npm@${stdout}`
+    }
+  });
+}

package/src/package-managers/npm/scaffolder.test.js

@@ -0,0 +1,33 @@
+import {promises as fs} from 'node:fs';
+import {execa} from 'execa';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import any from '@travi/any';
+import {vi, it, describe, expect} from 'vitest';
+import {when} from 'vitest-when';
+
+import scaffoldNpm from './scaffolder.js';
+
+vi.mock('node:fs');
+vi.mock('execa');
+vi.mock('@form8ion/javascript-core');
+
+describe('npm scaffolder', () => {
+  const projectRoot = any.string();
+
+  it('should scaffold the npm package manager', async () => {
+    const existingPackageContents = any.simpleObject();
+    const cliVersion = any.word();
+    when(fs.readFile)
+      .calledWith(`${projectRoot}/package.json`, 'utf-8')
+      .thenResolve(JSON.stringify(existingPackageContents));
+    when(execa).calledWith('npm', ['--version']).thenResolve({stdout: cliVersion});
+
+    await scaffoldNpm({projectRoot});
+
+    expect(writePackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {...existingPackageContents, packageManager: `npm@${cliVersion}`}
+    });
+  });
+});

package/src/package-managers/npm/tester.js

@@ -0,0 +1,11 @@
+import {fileExists} from '@form8ion/core';
+import {packageManagers} from '@form8ion/javascript-core';
+
+import determineLockfilePath from '../lockfile-path-resolver.js';
+
+export default function packageManagerIsNpm({projectRoot, pinnedPackageManager = ''}) {
+  const [packageManager] = pinnedPackageManager.split('@');
+
+  return packageManagers.NPM === packageManager
+    || fileExists(`${projectRoot}/${determineLockfilePath(packageManagers.NPM)}`);
+}

package/src/package-managers/npm/tester.test.js

@@ -0,0 +1,33 @@
+import {fileExists} from '@form8ion/core';
+
+import {expect, describe, it, vi, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import npmIsUsed from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('npm predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` is a `package-lock.json` exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/package-lock.json`).thenResolve(true);
+
+    expect(await npmIsUsed({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` is a `package-lock.json` does not exist', async () => {
+    when(fileExists).calledWith(`${projectRoot}/package-lock.json`).thenResolve(false);
+
+    expect(await npmIsUsed({projectRoot})).toBe(false);
+  });
+
+  it('should return true if the package manager is pinned to npm', async () => {
+    expect(await npmIsUsed({projectRoot, pinnedPackageManager: 'npm@1.2.3'})).toBe(true);
+  });
+});

package/src/package-managers/scaffolder.js

@@ -0,0 +1,11 @@
+import {scaffold as scaffoldNpm} from './npm/index.js';
+import {scaffold as scaffoldYarn} from './yarn/index.js';
+
+const scaffolders = {
+  npm: scaffoldNpm,
+  yarn: scaffoldYarn
+};
+
+export default function scaffoldPackageManager({projectRoot, packageManager}) {
+  return scaffolders[packageManager]({projectRoot});
+}