@form8ion/javascript 15.6.0 → 15.6.1

package/src/coverage/scaffolder.js

@@ -0,0 +1,7 @@
+import deepmerge from 'deepmerge';
+import {scaffold as scaffoldCodecov} from '@form8ion/codecov';
+import {scaffold as scaffoldC8} from '@form8ion/c8';
+
+export default async function scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent}) {
+  return deepmerge(await scaffoldC8({projectRoot}), await scaffoldCodecov({vcs, visibility, pathWithinParent}));
+}

package/src/coverage/scaffolder.test.js

@@ -0,0 +1,32 @@
+import {scaffold as scaffoldCodecov} from '@form8ion/codecov';
+import {scaffold as scaffoldC8} from '@form8ion/c8';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import scaffold from './scaffolder.js';
+
+vi.mock('@form8ion/codecov');
+vi.mock('@form8ion/c8');
+
+describe('coverage scaffolder', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should scaffold coverage measurement and reporting', async () => {
+    const vcs = any.simpleObject();
+    const visibility = any.word();
+    const projectRoot = any.string();
+    const c8Results = any.simpleObject();
+    const codecovResults = any.simpleObject();
+    const pathWithinParent = any.string();
+    when(scaffoldC8).calledWith({projectRoot}).thenResolve(c8Results);
+    when(scaffoldCodecov).calledWith({vcs, visibility, pathWithinParent}).thenResolve(codecovResults);
+
+    const results = await scaffold({vcs, visibility, projectRoot, pathWithinParent});
+
+    expect(results).toEqual({...c8Results, ...codecovResults});
+  });
+});

package/src/coverage/tester.js

@@ -0,0 +1,10 @@
+import {directoryExists} from '@form8ion/core';
+import {test as c8IsConfigured} from '@form8ion/c8';
+
+import nycIsConfigured from './nyc/tester.js';
+
+export default async function testCoverageBeingCollected({projectRoot}) {
+  const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({projectRoot}), nycIsConfigured({projectRoot})]);
+
+  return c8Exists || nycExists || directoryExists(`${projectRoot}/coverage`);
+}

package/src/coverage/tester.test.js

@@ -0,0 +1,50 @@
+import {directoryExists} from '@form8ion/core';
+import {test as c8IsPresent} from '@form8ion/c8';
+
+import any from '@travi/any';
+import {afterEach, vi, describe, expect, it} from 'vitest';
+import {when} from 'vitest-when';
+
+import nycIsPresent from './nyc/tester.js';
+import coverageIsConfigured from './tester.js';
+
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/c8');
+vi.mock('./nyc/tester.js');
+
+describe('coverage predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` when nyc is detected', async () => {
+    when(nycIsPresent).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await coverageIsConfigured({projectRoot})).toBe(true);
+  });
+
+  it('should return `true` when c8 is detected', async () => {
+    when(nycIsPresent).calledWith({projectRoot}).thenResolve(false);
+    when(c8IsPresent).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await coverageIsConfigured({projectRoot})).toBe(true);
+  });
+
+  it('should return `true` if the `coverage/` directory exists', async () => {
+    when(nycIsPresent).calledWith({projectRoot}).thenResolve(false);
+    when(c8IsPresent).calledWith({projectRoot}).thenResolve(false);
+    when(directoryExists).calledWith(`${projectRoot}/coverage`).thenResolve(true);
+
+    expect(await coverageIsConfigured({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` when neither c8 nor nyc are detected', async () => {
+    when(nycIsPresent).calledWith({projectRoot}).thenResolve(false);
+    when(c8IsPresent).calledWith({projectRoot}).thenResolve(false);
+    when(directoryExists).calledWith(`${projectRoot}/coverage`).thenResolve(false);
+
+    expect(await coverageIsConfigured({projectRoot})).toBe(false);
+  });
+});

package/src/dependencies/index.js

@@ -0,0 +1,3 @@
+export {default as install} from './installer.js';
+export {default as remove} from './remover.js';
+export {default as process} from './processor.js';

package/src/dependencies/installer.js

@@ -0,0 +1,25 @@
+import {info, warn} from '@travi/cli-messages';
+import {DEV_DEPENDENCY_TYPE, packageManagers} from '@form8ion/javascript-core';
+
+import {execa} from 'execa';
+import {getDependencyTypeFlag, getExactFlag, getInstallationCommandFor} from './package-managers.js';
+
+export default async function installDependencies(
+  dependencies,
+  dependenciesType,
+  projectRoot,
+  packageManager = packageManagers.NPM
+) {
+  if (dependencies.length) {
+    info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
+
+    await execa(
+      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${
+        getInstallationCommandFor(packageManager)
+      } ${[...new Set(dependencies)].join(' ')} --${getDependencyTypeFlag(packageManager, dependenciesType)}${
+        DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
+      }`,
+      {shell: true, cwd: projectRoot}
+    );
+  } else warn(`No ${dependenciesType} dependencies to install`);
+}

package/src/dependencies/installer.test.js

@@ -0,0 +1,77 @@
+import {execa} from 'execa';
+import {DEV_DEPENDENCY_TYPE, packageManagers} from '@form8ion/javascript-core';
+
+import {vi, it, describe, expect, beforeEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {getDependencyTypeFlag, getInstallationCommandFor, getExactFlag} from './package-managers.js';
+import install from './installer.js';
+
+vi.mock('execa');
+vi.mock('./package-managers.js');
+
+describe('dependencies installer', () => {
+  const projectRoot = any.string();
+  const packageManager = any.word();
+  const installationCommand = any.string();
+  const typeFlag = any.word();
+  const duplicateDependency = any.word();
+  const uniqueDependencies = any.listOf(any.word);
+  const dependencies = [duplicateDependency, ...uniqueDependencies, duplicateDependency];
+  const exactFlag = any.word();
+
+  beforeEach(() => {
+    when(getInstallationCommandFor).calledWith(packageManager).thenReturn(installationCommand);
+  });
+
+  it('should avoid execution when there are no dependencies to install', async () => {
+    await install([]);
+
+    expect(execa).not.toHaveBeenCalled();
+  });
+
+  it('should install dependencies', async () => {
+    const dependenciesType = any.word();
+    when(getDependencyTypeFlag).calledWith(packageManager, dependenciesType).thenReturn(typeFlag);
+
+    await install(dependencies, dependenciesType, projectRoot, packageManager);
+
+    expect(execa).toHaveBeenCalledWith(
+      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${installationCommand} ${
+        [duplicateDependency, ...uniqueDependencies].join(' ')
+      } --${typeFlag}`,
+      {shell: true, cwd: projectRoot}
+    );
+  });
+
+  it('should pin versions when installing dev-dependencies', async () => {
+    await install(dependencies, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    when(getDependencyTypeFlag).calledWith(packageManager, DEV_DEPENDENCY_TYPE).thenReturn(typeFlag);
+    when(getExactFlag).calledWith(packageManager).thenReturn(exactFlag);
+
+    await install(dependencies, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+
+    expect(execa).toHaveBeenCalledWith(
+      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${installationCommand} ${
+        [duplicateDependency, ...uniqueDependencies].join(' ')
+      } --${typeFlag} --${exactFlag}`,
+      {shell: true, cwd: projectRoot}
+    );
+  });
+
+  it('should default to `npm` when the package-manager is not specified', async () => {
+    when(getDependencyTypeFlag).calledWith(packageManagers.NPM, DEV_DEPENDENCY_TYPE).thenReturn(typeFlag);
+    when(getExactFlag).calledWith(packageManagers.NPM).thenReturn(exactFlag);
+    when(getInstallationCommandFor).calledWith(packageManagers.NPM).thenReturn(installationCommand);
+
+    await install(dependencies, DEV_DEPENDENCY_TYPE, projectRoot);
+
+    expect(execa).toHaveBeenCalledWith(
+      `. ~/.nvm/nvm.sh && nvm use && ${packageManagers.NPM} ${installationCommand} ${
+        [duplicateDependency, ...uniqueDependencies].join(' ')
+      } --${typeFlag} --${exactFlag}`,
+      {shell: true, cwd: projectRoot}
+    );
+  });
+});

package/src/dependencies/package-managers.js

@@ -0,0 +1,32 @@
+import {DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE, packageManagers} from '@form8ion/javascript-core';
+
+export const details = {
+  [packageManagers.NPM]: {
+    installationCommand: 'install',
+    installationFlags: {
+      [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
+      [PROD_DEPENDENCY_TYPE]: `save-${PROD_DEPENDENCY_TYPE}`,
+      exact: 'save-exact'
+    }
+  },
+  [packageManagers.YARN]: {
+    installationCommand: 'add',
+    installationFlags: {
+      [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
+      [PROD_DEPENDENCY_TYPE]: PROD_DEPENDENCY_TYPE,
+      exact: 'exact'
+    }
+  }
+};
+
+export function getInstallationCommandFor(manager) {
+  return details[manager].installationCommand;
+}
+
+export function getDependencyTypeFlag(manager, type) {
+  return details[manager].installationFlags[type];
+}
+
+export function getExactFlag(manager) {
+  return details[manager].installationFlags.exact;
+}

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

@@ -0,0 +1,46 @@
+import {DEV_DEPENDENCY_TYPE, packageManagers, PROD_DEPENDENCY_TYPE} from '@form8ion/javascript-core';
+
+import {describe, expect, it} from 'vitest';
+import {details, getDependencyTypeFlag, getExactFlag, getInstallationCommandFor} from './package-managers.js';
+
+describe('package managers', () => {
+  describe('details', () => {
+    it('should map the names to the cli names', () => {
+      expect(packageManagers.NPM).toEqual('npm');
+      expect(packageManagers.YARN).toEqual('yarn');
+    });
+
+    it('should define installation details for npm correctly', () => {
+      const {installationCommand, installationFlags} = details[packageManagers.NPM];
+
+      expect(installationCommand).toEqual('install');
+      expect(installationFlags[DEV_DEPENDENCY_TYPE]).toEqual('save-dev');
+      expect(installationFlags[PROD_DEPENDENCY_TYPE]).toEqual('save-prod');
+      expect(installationFlags.exact).toEqual('save-exact');
+    });
+
+    it('should define installation details correctly for yarn', () => {
+      const {installationCommand, installationFlags} = details[packageManagers.YARN];
+
+      expect(installationCommand).toEqual('add');
+      expect(installationFlags[DEV_DEPENDENCY_TYPE]).toEqual('dev');
+      expect(installationFlags[PROD_DEPENDENCY_TYPE]).toEqual('prod');
+      expect(installationFlags.exact).toEqual('exact');
+    });
+  });
+
+  describe('resolvers', () => {
+    function assertPackageManagerDetails(manager) {
+      const {installationCommand, installationFlags} = details[manager];
+
+      expect(getInstallationCommandFor(manager)).toEqual(installationCommand);
+      expect(getDependencyTypeFlag(manager, DEV_DEPENDENCY_TYPE)).toEqual(installationFlags[DEV_DEPENDENCY_TYPE]);
+      expect(getDependencyTypeFlag(manager, PROD_DEPENDENCY_TYPE)).toEqual(installationFlags[PROD_DEPENDENCY_TYPE]);
+      expect(getExactFlag(manager)).toEqual(installationFlags.exact);
+    }
+
+    it('should resolve the proper details for npm', () => assertPackageManagerDetails(packageManagers.NPM));
+
+    it('should resolve the proper details for yarn', () => assertPackageManagerDetails(packageManagers.YARN));
+  });
+});

package/src/dependencies/processor.js

@@ -0,0 +1,30 @@
+import {error, info} from '@travi/cli-messages';
+import {DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE} from '@form8ion/javascript-core';
+
+import install from './installer.js';
+import remove from './remover.js';
+
+export default async function processDependencies({dependencies = {}, devDependencies, projectRoot, packageManager}) {
+  info('Processing dependencies');
+
+  if (Array.isArray(devDependencies)) {
+    throw new Error(
+      `devDependencies provided as: ${devDependencies}. Instead, provide under dependencies.javascript.development`
+    );
+  }
+
+  if (Array.isArray(dependencies)) {
+    throw new Error(`Expected dependencies to be an object. Instead received: ${dependencies}`);
+  }
+
+  const {javascript: {production = [], development = [], remove: dependenciesToRemove = []} = {}} = dependencies;
+
+  try {
+    await install(production, PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await install(development, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await remove({packageManager, dependencies: dependenciesToRemove});
+  } catch (e) {
+    error('Failed to update dependencies');
+    error(e, {level: 'secondary'});
+  }
+}

package/src/dependencies/processor.test.js

@@ -0,0 +1,75 @@
+import {DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE} from '@form8ion/javascript-core';
+
+import {describe, it, expect, vi} from 'vitest';
+import any from '@travi/any';
+
+import installDependencies from './installer.js';
+import removeDependencies from './remover.js';
+import processDependencies from './processor.js';
+
+vi.mock('./installer.js');
+vi.mock('./remover.js');
+
+describe('dependencies processor', () => {
+  const projectRoot = any.string();
+  const packageManager = any.word();
+
+  it('should process the provided dependency lists', async () => {
+    const production = any.listOf(any.word);
+    const development = any.listOf(any.word);
+    const remove = any.listOf(any.word);
+
+    await processDependencies({
+      dependencies: {javascript: {production, development, remove}},
+      projectRoot,
+      packageManager
+    });
+
+    expect(installDependencies).toHaveBeenCalledWith(production, PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(installDependencies).toHaveBeenCalledWith(development, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(removeDependencies).toHaveBeenCalledWith({packageManager, dependencies: remove});
+  });
+
+  it('should process as empty lists when dependencies are not provided', async () => {
+    await processDependencies({projectRoot, packageManager});
+
+    expect(installDependencies).toHaveBeenCalledWith([], PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(installDependencies).toHaveBeenCalledWith([], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+  });
+
+  it('should process as empty lists when javascript dependencies are not provided', async () => {
+    await processDependencies({projectRoot, packageManager, dependencies: {}});
+
+    expect(installDependencies).toHaveBeenCalledWith([], PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(installDependencies).toHaveBeenCalledWith([], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+  });
+
+  it('should process as empty lists when dependency types are not provided', async () => {
+    await processDependencies({projectRoot, packageManager, dependencies: {javascript: {}}});
+
+    expect(installDependencies).toHaveBeenCalledWith([], PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(installDependencies).toHaveBeenCalledWith([], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    expect(removeDependencies).toHaveBeenCalledWith({packageManager, dependencies: []});
+  });
+
+  it('should prevent an installation error from bubbling', async () => {
+    installDependencies.mockRejectedValue(new Error());
+
+    await expect(() => processDependencies({dependencies: {javascript: {}}})).not.toThrowError();
+  });
+
+  it('should throw an error if dependencies is defined as an array rather than an object', async () => {
+    const dependencies = any.listOf(any.word);
+
+    await expect(() => processDependencies({dependencies}))
+      .rejects.toThrowError(`Expected dependencies to be an object. Instead received: ${dependencies}`);
+  });
+
+  it('should throw an error if devDependencies is defined as an array', async () => {
+    const devDependencies = any.listOf(any.word);
+
+    await expect(() => processDependencies({devDependencies})).rejects.toThrowError(
+      `devDependencies provided as: ${devDependencies}. Instead, provide under dependencies.javascript.development`
+    );
+  });
+});

package/src/dependencies/remover.js

@@ -0,0 +1,10 @@
+import {execa} from 'execa';
+import {info} from '@travi/cli-messages';
+
+export default async function removeDependencies({packageManager, dependencies}) {
+  if (dependencies.length) {
+    info('Removing dependencies dependencies', {level: 'secondary'});
+
+    await execa(packageManager, ['remove', ...dependencies]);
+  }
+}

package/src/dependencies/remover.test.js

@@ -0,0 +1,28 @@
+import {execa} from 'execa';
+
+import any from '@travi/any';
+import {describe, it, expect, vi} from 'vitest';
+
+import removeDependencies from './remover.js';
+
+vi.mock('execa');
+
+describe('dependency remover', () => {
+  it('should remove the dependencies using the named package manager', async () => {
+    const packageManager = any.word();
+    const dependencies = any.listOf(any.word);
+
+    await removeDependencies({packageManager, dependencies});
+
+    expect(execa).toHaveBeenCalledWith(packageManager, ['remove', ...dependencies]);
+  });
+
+  it('should not attempt to remove when no dependencies are provided', async () => {
+    const packageManager = any.word();
+    const dependencies = [];
+
+    await removeDependencies({packageManager, dependencies});
+
+    expect(execa).not.toHaveBeenCalled();
+  });
+});

package/src/dialects/babel/config/ignore-adder.js

@@ -0,0 +1,10 @@
+import writeConfig from './writer.js';
+import loadConfig from './loader.js';
+
+export default async function addIgnores({projectRoot, ignore}) {
+  if (ignore) {
+    const existingConfig = await loadConfig({projectRoot});
+
+    await writeConfig({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
+  }
+}

package/src/dialects/babel/config/ignore-adder.test.js

@@ -0,0 +1,33 @@
+import any from '@travi/any';
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+
+import writeConfig from './writer.js';
+import loadConfig from './loader.js';
+import addIgnore from './ignore-adder.js';
+
+vi.mock('node:fs');
+vi.mock('./writer.js');
+vi.mock('./loader.js');
+
+describe('babel ignore adder', () => {
+  const projectRoot = any.string();
+
+  it('should add the provided ignore to the existing config', async () => {
+    const pathToIgnore = any.string();
+    const existingConfig = any.simpleObject();
+    when(loadConfig).calledWith({projectRoot}).thenResolve(existingConfig);
+
+    await addIgnore({projectRoot, ignore: pathToIgnore});
+
+    expect(writeConfig)
+      .toHaveBeenCalledWith({projectRoot, config: {...existingConfig, ignore: [`./${pathToIgnore}/`]}});
+  });
+
+  it('should not update the config if no `buildDirectory` is provided', async () => {
+    await addIgnore({projectRoot});
+
+    expect(loadConfig).not.toHaveBeenCalled();
+    expect(writeConfig).not.toHaveBeenCalled();
+  });
+});

package/src/dialects/babel/config/index.js

@@ -0,0 +1,3 @@
+export {default as write} from './writer.js';
+export {default as load} from './loader.js';
+export {default as addIgnore} from './ignore-adder.js';

package/src/dialects/babel/config/loader.js

@@ -0,0 +1,5 @@
+import {fileTypes, loadConfigFile} from '@form8ion/core';
+
+export default function loadBabelConfig({projectRoot}) {
+  return loadConfigFile({path: projectRoot, name: '.babelrc', format: fileTypes.JSON});
+}

package/src/dialects/babel/config/loader.test.js

@@ -0,0 +1,21 @@
+import {fileTypes, loadConfigFile} from '@form8ion/core';
+
+import {describe, it, expect, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import loadConfig from './loader.js';
+
+vi.mock('@form8ion/core');
+
+describe('babel config loader', () => {
+  it('should load config from an existing config file', async () => {
+    const projectRoot = any.string();
+    const parsedConfig = any.simpleObject();
+    when(loadConfigFile)
+      .calledWith({name: '.babelrc', format: fileTypes.JSON, path: projectRoot})
+      .thenResolve(parsedConfig);
+
+    expect(await loadConfig({projectRoot})).toEqual(parsedConfig);
+  });
+});

package/src/dialects/babel/config/writer.js

@@ -0,0 +1,6 @@
+import {fileTypes} from '@form8ion/core';
+import {write} from '@form8ion/config-file';
+
+export default function writeBabelConfig({projectRoot, config}) {
+  return write({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+}

package/src/dialects/babel/config/writer.test.js

@@ -0,0 +1,20 @@
+import * as configFile from '@form8ion/config-file';
+import {fileTypes} from '@form8ion/core';
+
+import any from '@travi/any';
+import {describe, expect, it, vi} from 'vitest';
+
+import write from './writer.js';
+
+vi.mock('@form8ion/config-file');
+
+describe('babel config writer', () => {
+  it('should write the provided config to the rc file', async () => {
+    const projectRoot = any.string();
+    const config = any.simpleObject();
+
+    await write({projectRoot, config});
+
+    expect(configFile.write).toHaveBeenCalledWith({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+  });
+});

package/src/dialects/babel/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as lift} from './lifter.js';
+export {default as test} from './predicate.js';

package/src/dialects/babel/lifter.js

@@ -0,0 +1,7 @@
+import {addIgnore} from './config/index.js';
+
+export default async function liftBabel({results, projectRoot}) {
+  await addIgnore({ignore: results.buildDirectory, projectRoot});
+
+  return {};
+}

package/src/dialects/babel/lifter.test.js

@@ -0,0 +1,17 @@
+import any from '@travi/any';
+import {describe, expect, it, vi} from 'vitest';
+
+import addIgnore from './config/ignore-adder.js';
+import lift from './lifter.js';
+
+vi.mock('./config/ignore-adder.js');
+
+describe('babel-lifter', () => {
+  it('should ignore the build directory', async () => {
+    const projectRoot = any.string();
+    const buildDirectory = any.string();
+
+    expect(await lift({results: {buildDirectory}, projectRoot})).toEqual({});
+    expect(addIgnore).toHaveBeenCalledWith({ignore: buildDirectory, projectRoot});
+  });
+});

package/src/dialects/babel/predicate.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function babelIsInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.babelrc.json`);
+}

package/src/dialects/babel/predicate.test.js

@@ -0,0 +1,25 @@
+import {fileExists} from '@form8ion/core';
+
+import {expect, describe, vi, it} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import babelExists from './predicate.js';
+
+vi.mock('@form8ion/core');
+
+describe('babel predicate', () => {
+  const projectRoot = any.string();
+
+  it('should return `true` when a babel config exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.babelrc.json`).thenResolve(true);
+
+    expect(await babelExists({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` when a babel config exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.babelrc.json`).thenResolve(false);
+
+    expect(await babelExists({projectRoot})).toBe(false);
+  });
+});

package/src/dialects/babel/scaffolder.js

@@ -0,0 +1,14 @@
+import {write} from './config/index.js';
+
+export default async function scaffoldBabel({projectRoot, preset}) {
+  if (!preset) {
+    throw new Error('No babel preset provided. Cannot configure babel transpilation');
+  }
+
+  await write({projectRoot, config: {presets: [preset.name]}});
+
+  return {
+    dependencies: {javascript: {development: ['@babel/register', preset.packageName]}},
+    eslint: {}
+  };
+}

package/src/dialects/babel/scaffolder.test.js

@@ -0,0 +1,28 @@
+import any from '@travi/any';
+import {describe, it, expect, vi} from 'vitest';
+
+import {write} from './config/index.js';
+import scaffoldBabel from './scaffolder.js';
+
+vi.mock('./config/index.js');
+
+describe('babel scaffolder', () => {
+  const projectRoot = any.string();
+
+  it('should write the babelrc if a preset is provided', async () => {
+    const babelPresetName = any.string();
+    const babelPresetPackageName = any.word();
+    const babelPreset = {name: babelPresetName, packageName: babelPresetPackageName};
+
+    expect(await scaffoldBabel({preset: babelPreset, projectRoot, tests: {unit: true}}))
+      .toEqual({dependencies: {javascript: {development: ['@babel/register', babelPresetPackageName]}}, eslint: {}});
+    expect(write).toHaveBeenCalledWith({projectRoot, config: {presets: [babelPresetName]}});
+  });
+
+  it('should throw an error if a preset is not defined', async () => {
+    await expect(() => scaffoldBabel({preset: undefined, projectRoot}))
+      .rejects.toThrowError('No babel preset provided. Cannot configure babel transpilation');
+
+    expect(write).not.toHaveBeenCalled();
+  });
+});

package/src/dialects/index.js

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