@form8ion/javascript 13.0.0-beta.1 → 13.0.0-beta.11

package/lib/index.js

@@ -1,69 +1,33 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var languageScaffolderPrompts = require('@travi/language-scaffolder-prompts');
-var deepmerge = require('deepmerge');
-var core = require('@form8ion/core');
-var javascriptCore = require('@form8ion/javascript-core');
-var joi = require('joi');
-var overridablePrompts = require('@form8ion/overridable-prompts');
-var codecov = require('@form8ion/codecov');
-var configFile = require('@form8ion/config-file');
-var cliMessages = require('@travi/cli-messages');
-var commitConventionPlugin = require('@form8ion/commit-convention');
-var execa = require('@form8ion/execa-wrapper');
-var npmConf = require('npm-conf');
-var os = require('os');
-var validatePackageName = require('validate-npm-package-name');
-var fs = require('fs');
-var mustache = require('mustache');
-var mkdir = require('make-dir');
-var touch = require('touch');
-var camelcase = require('camelcase');
-var path = require('path');
-var filedirname = require('filedirname');
-var huskyPlugin = require('@form8ion/husky');
-var node_fs = require('node:fs');
-var ini = require('ini');
-var prettier = require('@form8ion/prettier');
-var eslintPlugin = require('@form8ion/eslint');
-var sortProperties = require('sort-object-keys');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var deepmerge__default = /*#__PURE__*/_interopDefaultLegacy(deepmerge);
-var joi__default = /*#__PURE__*/_interopDefaultLegacy(joi);
-var commitConventionPlugin__namespace = /*#__PURE__*/_interopNamespace(commitConventionPlugin);
-var execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
-var npmConf__default = /*#__PURE__*/_interopDefaultLegacy(npmConf);
-var validatePackageName__default = /*#__PURE__*/_interopDefaultLegacy(validatePackageName);
-var mustache__default = /*#__PURE__*/_interopDefaultLegacy(mustache);
-var mkdir__default = /*#__PURE__*/_interopDefaultLegacy(mkdir);
-var touch__default = /*#__PURE__*/_interopDefaultLegacy(touch);
-var camelcase__default = /*#__PURE__*/_interopDefaultLegacy(camelcase);
-var filedirname__default = /*#__PURE__*/_interopDefaultLegacy(filedirname);
-var huskyPlugin__namespace = /*#__PURE__*/_interopNamespace(huskyPlugin);
-var eslintPlugin__namespace = /*#__PURE__*/_interopNamespace(eslintPlugin);
-var sortProperties__default = /*#__PURE__*/_interopDefaultLegacy(sortProperties);
+import { questionNames as questionNames$2, questions } from '@travi/language-scaffolder-prompts';
+import deepmerge from 'deepmerge';
+import { fileTypes, fileExists, optionsSchemas, validateOptions, applyEnhancers, writeConfigFile } from '@form8ion/core';
+import { scaffoldChoice, packageManagers as packageManagers$1, projectTypes as projectTypes$1, mergeIntoExistingPackageJson, dialects as dialects$1, writePackageJson, DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE } from '@form8ion/javascript-core';
+import { prompt as prompt$1 } from '@form8ion/overridable-prompts';
+import joi from 'joi';
+import { scaffold, lift as lift$3 } from '@form8ion/codecov';
+import { write as write$2, load } from '@form8ion/config-file';
+import { info, warn, error } from '@travi/cli-messages';
+import * as commitConventionPlugin from '@form8ion/commit-convention';
+import { scaffold as scaffold$4 } from '@form8ion/commit-convention';
+import execa from '@form8ion/execa-wrapper';
+import npmConf from 'npm-conf';
+import { EOL } from 'os';
+import validatePackageName from 'validate-npm-package-name';
+import { promises } from 'fs';
+import mustache from 'mustache';
+import mkdir from 'make-dir';
+import touch from 'touch';
+import camelcase from 'camelcase';
+import { resolve } from 'path';
+import filedirname from 'filedirname';
+import * as huskyPlugin from '@form8ion/husky';
+import { scaffold as scaffold$3 } from '@form8ion/husky';
+import { promises as promises$1 } from 'node:fs';
+import { stringify, parse } from 'ini';
+import { scaffold as scaffold$2 } from '@form8ion/prettier';
+import * as eslintPlugin from '@form8ion/eslint';
+import { scaffold as scaffold$1, test as test$1 } from '@form8ion/eslint';
+import sortProperties from 'sort-object-keys';
 
 const questionNames$1 = {
   UNIT_TEST_FRAMEWORK: 'unitTestFramework',
@@ -84,9 +48,9 @@ const questionNames$1 = {
 };
 
 async function scaffoldC8 ({projectRoot}) {
-  await configFile.write({
+  await write$2({
     name: 'c8',
-    format: core.fileTypes.JSON,
+    format: fileTypes.JSON,
     path: projectRoot,
     config: {
       reporter: ['lcov', 'text-summary', 'html'],
@@ -102,27 +66,27 @@ async function scaffoldC8 ({projectRoot}) {
 }
 
 async function scaffoldCoverage ({projectRoot, vcs, visibility, pathWithinParent}) {
-  return deepmerge__default["default"](await scaffoldC8({projectRoot}), await codecov.scaffold({vcs, visibility, pathWithinParent}));
+  return deepmerge(await scaffoldC8({projectRoot}), await scaffold({vcs, visibility, pathWithinParent}));
 }
 
 function nycIsConfigured ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/.nycrc`);
+  return fileExists(`${projectRoot}/.nycrc`);
 }
 
 async function removeDependencies ({packageManager, dependencies}) {
-  await execa__default["default"](packageManager, ['remove', ...dependencies]);
+  await execa(packageManager, ['remove', ...dependencies]);
 }
 
 async function removeNyc ({projectRoot, packageManager}) {
   await Promise.all([
-    fs.promises.unlink(`${projectRoot}/.nycrc`),
-    fs.promises.rm(`${projectRoot}/.nyc_output`, {recursive: true, force: true}),
+    promises.unlink(`${projectRoot}/.nycrc`),
+    promises.rm(`${projectRoot}/.nyc_output`, {recursive: true, force: true}),
     removeDependencies({packageManager, dependencies: ['nyc', '@istanbuljs/nyc-config-babel', 'babel-plugin-istanbul']})
   ]);
 }
 
 async function lift$2({projectRoot, packageManager, vcs}) {
-  const codecovResults = await codecov.lift({projectRoot, packageManager, vcs});
+  const codecovResults = await lift$3({projectRoot, packageManager, vcs});
 
   if (await nycIsConfigured({projectRoot})) {
     const [c8Results] = await Promise.all([
@@ -130,7 +94,7 @@ async function lift$2({projectRoot, packageManager, vcs}) {
       removeNyc({projectRoot, packageManager})
     ]);
 
-    return deepmerge__default["default"].all([
+    return deepmerge.all([
       c8Results,
       codecovResults,
       {
@@ -147,10 +111,10 @@ async function lift$2({projectRoot, packageManager, vcs}) {
 }
 
 function c8IsConfigured ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/.c8rc.json`);
+  return fileExists(`${projectRoot}/.c8rc.json`);
 }
 
-async function tester$4 ({projectRoot}) {
+async function tester$5 ({projectRoot}) {
   const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({projectRoot}), nycIsConfigured({projectRoot})]);
 
   return c8Exists || nycExists;
@@ -158,46 +122,259 @@ async function tester$4 ({projectRoot}) {
 
 var coveragePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  scaffold: scaffoldCoverage,
   lift: lift$2,
-  test: tester$4
+  scaffold: scaffoldCoverage,
+  test: tester$5
 });
 
-const unitTestFrameworksSchema = joi__default["default"].object().required().pattern(/^/, joi__default["default"].object({
-  scaffolder: joi__default["default"].func().arity(1).required()
-}));
-
 async function chooseFramework ({frameworks, decisions}) {
   if (!Object.keys(frameworks).length) return 'Other';
 
-  const answers = await overridablePrompts.prompt([{
+  const answers = await prompt$1([{
     name: questionNames$1.UNIT_TEST_FRAMEWORK,
     type: 'list',
     message: 'Which type of unit testing framework should be used?',
-    choices: [...Object.keys(frameworks), new overridablePrompts.Separator(), 'Other']
+    choices: [...Object.keys(frameworks), 'Other']
   }], decisions);
 
   return answers[questionNames$1.UNIT_TEST_FRAMEWORK];
 }
 
+const pluginsSchema = joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});
+
 async function scaffoldUnitTesting ({projectRoot, frameworks, decisions, visibility, vcs, pathWithinParent, dialect}) {
-  const validatedFrameworks = core.validateOptions(unitTestFrameworksSchema, frameworks);
+  const validatedFrameworks = validateOptions(pluginsSchema, frameworks);
   const [framework, coverage] = await Promise.all([
     chooseFramework({frameworks: validatedFrameworks, decisions})
-      .then(chosenFramework => javascriptCore.scaffoldChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
+      .then(chosenFramework => scaffoldChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
     scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent})
   ]);
 
-  return deepmerge__default["default"].all([
+  return deepmerge.all([
     {scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'}},
     framework,
     coverage
   ]);
 }
 
+function tester$4 () {
+  return true;
+}
+
+function buildAllowedHostsList ({packageManager, registries = {}}) {
+  return [
+    ...!registries.registry ? [packageManager] : [],
+    ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
+  ];
+}
+
+function determineLockfilePathFor (packageManager) {
+  const lockfilePaths = {
+    [packageManagers$1.NPM]: 'package-lock.json',
+    [packageManagers$1.YARN]: 'yarn.lock'
+  };
+
+  return lockfilePaths[packageManager];
+}
+
+function npmIsUsed ({projectRoot}) {
+  return fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.NPM)}`);
+}
+
+function yarnIsUsed ({projectRoot}) {
+  return fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.YARN)}`);
+}
+
+async function jsPackageManagerIsUsed ({projectRoot}) {
+  const [npmFound, yarnFound] = await Promise.all([
+    npmIsUsed({projectRoot}),
+    yarnIsUsed({projectRoot})
+  ]);
+
+  return npmFound || yarnFound;
+}
+
+async function liftCorepack () {
+  await execa('corepack', ['use', 'npm@latest']);
+}
+
+async function lifter$5 () {
+  await liftCorepack();
+
+  return {};
+}
+
+async function resolvePackageManager ({projectRoot, packageManager}) {
+  if (packageManager) return packageManager;
+
+  if (await npmIsUsed({projectRoot})) {
+    return packageManagers$1.NPM;
+  }
+
+  if (await yarnIsUsed({projectRoot})) {
+    return packageManagers$1.YARN;
+  }
+
+  throw new Error('Package-manager could not be determined');
+}
+
+var packageManagers = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  defineLockfilePath: determineLockfilePathFor,
+  determineCurrent: resolvePackageManager,
+  lift: lifter$5,
+  test: jsPackageManagerIsUsed
+});
+
+const lockfileLintSupportedPackageManagers = [packageManagers$1.NPM, packageManagers$1.YARN];
+
+function lockfileLintSupports(packageManager) {
+  return lockfileLintSupportedPackageManagers.includes(packageManager);
+}
+
+async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
+  if (!lockfileLintSupports(packageManager)) {
+    throw new Error(
+      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
+      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
+    );
+  }
+
+  await write$2({
+    name: 'lockfile-lint',
+    format: fileTypes.JSON,
+    path: projectRoot,
+    config: {
+      path: determineLockfilePathFor(packageManager),
+      type: packageManager,
+      'validate-https': true,
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+
+  return {
+    devDependencies: ['lockfile-lint'],
+    scripts: {'lint:lockfile': 'lockfile-lint'}
+  };
+}
+
+function lockfileLintIsAlreadyConfigured ({projectRoot}) {
+  return fileExists(`${projectRoot}/.lockfile-lintrc.json`);
+}
+
+const configName = 'lockfile-lint';
+
+function read() {
+  return load({name: configName});
+}
+
+function write$1({projectRoot, config}) {
+  return write$2({name: configName, format: fileTypes.JSON, path: projectRoot, config});
+}
+
+async function writeNpmConfig ({projectRoot, config}) {
+  await promises$1.writeFile(`${projectRoot}/.npmrc`, stringify(config));
+}
+
+function projectWillNotBeConsumed(projectType) {
+  return projectTypes$1.APPLICATION === projectType || projectTypes$1.CLI === projectType;
+}
+
+async function scaffoldNpmConfig ({projectRoot, projectType}) {
+  await writeNpmConfig({
+    projectRoot,
+    config: {'update-notifier': false, ...projectWillNotBeConsumed(projectType) && {'save-exact': true}}
+  });
+
+  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
+}
+
+function tester$3 ({projectRoot}) {
+  return fileExists(`${projectRoot}/.npmrc`);
+}
+
+async function readNpmConfig ({projectRoot}) {
+  const pathToConfig = `${projectRoot}/.npmrc`;
+
+  if (!(await fileExists(pathToConfig))) return {};
+
+  return parse(await promises$1.readFile(pathToConfig, 'utf-8'));
+}
+
+async function lifter$4 ({projectRoot}) {
+  const {
+    provenance,
+    'engines-strict': enginesStrict,
+    ...remainingProperties
+  } = await readNpmConfig({projectRoot});
+
+  await writeNpmConfig({projectRoot, config: remainingProperties});
+
+  return {};
+}
+
+var npmConfigPlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter$4,
+  read: readNpmConfig,
+  scaffold: scaffoldNpmConfig,
+  test: tester$3,
+  write: writeNpmConfig
+});
+
+function buildRegistriesConfig (registries = {}) {
+  return Object.entries(registries)
+    .filter(([scope]) => 'publish' !== scope)
+    .reduce((acc, [scope, url]) => {
+      if ('registry' === scope) return {...acc, registry: url};
+
+      return {...acc, [`@${scope}:registry`]: url};
+    }, {registry: 'https://registry.npmjs.org'});
+}
+
+async function updateRegistriesInNpmConfig(registries, projectRoot) {
+  const registriesForNpmConfig = buildRegistriesConfig(registries);
+
+  await writeNpmConfig({
+    projectRoot,
+    config: {
+      ...(await readNpmConfig({projectRoot})),
+      ...registriesForNpmConfig
+    }
+  });
+}
+
+async function updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries) {
+  await write$1({
+    projectRoot,
+    config: {
+      ...await read(),
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+}
+
+async function lifter$3 ({projectRoot, packageManager, configs: {registries}}) {
+  await updateRegistriesInNpmConfig(registries, projectRoot);
+
+  if (!(await lockfileLintIsAlreadyConfigured({projectRoot}))) {
+    return scaffoldLockfileLint({projectRoot, packageManager, registries});
+  }
+
+  await updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries);
+
+  return {};
+}
+
+var registriesPlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter$3,
+  test: tester$4
+});
+
 async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
-  await configFile.write({
-    format: core.fileTypes.JSON,
+  await write$2({
+    format: fileTypes.JSON,
     path: projectRoot,
     name: 'remark',
     config: {
@@ -211,13 +388,13 @@ async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
       plugins: [
         config,
         ['remark-toc', {tight: true}],
-        ...javascriptCore.projectTypes.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
+        ...projectTypes$1.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
         ...!vcs ? [['validate-links', {repository: false}]] : []
       ]
     }
   });
 
-  return deepmerge__default["default"](
+  return deepmerge(
     {
       devDependencies: [config, 'remark-cli', 'remark-toc'],
       scripts: {
@@ -225,7 +402,7 @@ async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
         'generate:md': 'remark . --output'
       }
     },
-    {...javascriptCore.projectTypes.PACKAGE === projectType && {devDependencies: ['remark-usage']}}
+    {...projectTypes$1.PACKAGE === projectType && {devDependencies: ['remark-usage']}}
   );
 }
 
@@ -236,93 +413,37 @@ async function scaffoldCodeStyle ({
   vcs,
   configureLinting
 }) {
-  return deepmerge__default["default"].all(await Promise.all([
+  return deepmerge.all(await Promise.all([
     configs.eslint
       && configureLinting
-      && eslintPlugin.scaffold({projectRoot, config: configs.eslint}),
+      && scaffold$1({projectRoot, config: configs.eslint}),
     scaffoldRemark({
       projectRoot,
       projectType,
       vcs,
       config: configs.remark || '@form8ion/remark-lint-preset'
     }),
-    prettier.scaffold({projectRoot, config: configs.prettier})
+    scaffold$2({projectRoot, config: configs.prettier})
   ].filter(Boolean)));
 }
 
-function lifter$4 (options) {
-  return core.applyEnhancers({options, enhancers: [eslintPlugin__namespace]});
+function lifter$2 (options) {
+  return applyEnhancers({options, enhancers: [eslintPlugin]});
 }
 
-function tester$3 (options) {
-  return eslintPlugin.test(options);
+function tester$2 (options) {
+  return test$1(options);
 }
 
 var codeStylePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  lift: lifter$2,
   scaffold: scaffoldCodeStyle,
-  lift: lifter$4,
-  test: tester$3
-});
-
-async function write$1 ({projectRoot, config}) {
-  await node_fs.promises.writeFile(`${projectRoot}/.npmrc`, ini.stringify(config));
-}
-
-function projectWillNotBeConsumed(projectType) {
-  return javascriptCore.projectTypes.APPLICATION === projectType || javascriptCore.projectTypes.CLI === projectType;
-}
-
-async function scaffoldNpmConfig ({
-  projectRoot,
-  projectType,
-  registries
-}) {
-  await write$1({
-    projectRoot,
-    config: {
-      'update-notifier': false,
-      ...projectWillNotBeConsumed(projectType) && {'save-exact': true},
-      ...Object.fromEntries(Object.entries(registries)
-        .filter(([scope]) => 'publish' !== scope)
-        .map(([scope, url]) => {
-          if ('registry' === scope) return ['registry', url];
-
-          return [`@${scope}:registry`, url];
-        }))
-    }
-  });
-
-  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
-}
-
-function tester$2 ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/.npmrc`);
-}
-
-async function lifter$3 ({projectRoot}) {
-  const pathToConfig = `${projectRoot}/.npmrc`;
-
-  const {
-    provenance,
-    'engines-strict': enginesStrict,
-    ...remainingProperties
-  } = ini.parse(await node_fs.promises.readFile(pathToConfig, 'utf-8'));
-
-  await node_fs.promises.writeFile(pathToConfig, ini.stringify(remainingProperties));
-
-  return {};
-}
-
-var npmConfigPlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldNpmConfig,
-  test: tester$2,
-  lift: lifter$3
+  test: tester$2
 });
 
 async function test({projectRoot}) {
-  const {engines} = JSON.parse(await fs.promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+  const {engines} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
 
   return !!engines?.node;
 }
@@ -337,27 +458,27 @@ async function lift$1({packageDetails: {name}}) {
 
 var enginesEnhancer = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  test: test,
-  lift: lift$1
+  lift: lift$1,
+  test: test
 });
 
 function buildDocumentationCommand (packageManager) {
-  if (javascriptCore.packageManagers.NPM === packageManager) return 'npm run generate:md';
-  if (javascriptCore.packageManagers.YARN === packageManager) return 'yarn generate:md';
+  if (packageManagers$1.NPM === packageManager) return 'npm run generate:md';
+  if (packageManagers$1.YARN === packageManager) return 'yarn generate:md';
 
   throw new Error(
     `The ${packageManager} package manager is currently not supported. `
-    + `Only ${Object.values(javascriptCore.packageManagers).join(' and ')} are currently supported.`
+    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
   );
 }
 
 function getInstallationCommand(packageManager) {
-  if (javascriptCore.packageManagers.NPM === packageManager) return 'npm install';
-  if (javascriptCore.packageManagers.YARN === packageManager) return 'yarn add';
+  if (packageManagers$1.NPM === packageManager) return 'npm install';
+  if (packageManagers$1.YARN === packageManager) return 'yarn add';
 
   throw new Error(
     `The ${packageManager} package manager is currently not supported. `
-    + `Only ${Object.values(javascriptCore.packageManagers).join(' and ')} are currently supported.`
+    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
   );
 }
 
@@ -423,7 +544,7 @@ async function liftProvenance ({projectRoot, packageDetails}) {
   const {publishConfig: {access}} = packageDetails;
 
   if ('public' === access) {
-    await javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
+    await mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
 
     return enhanceSlsa({provenance: true});
   }
@@ -435,9 +556,9 @@ async function liftPublishable ({projectRoot, packageDetails}) {
   const {name: packageName, publishConfig: {access: packageAccessLevel}} = packageDetails;
   const homepage = `https://npm.im/${packageName}`;
 
-  await javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+  await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
 
-  return deepmerge__default["default"](
+  return deepmerge(
     await liftProvenance({packageDetails, projectRoot}),
     {
       homepage,
@@ -457,7 +578,7 @@ async function scaffoldPublishable ({packageName, packageAccessLevel}) {
 async function chooseBundler ({bundlers, decisions}) {
   if (!Object.keys(bundlers).length) return 'Other';
 
-  const answers = await overridablePrompts.prompt([{
+  const answers = await prompt$1([{
     name: questionNames$1.PACKAGE_BUNDLER,
     type: 'list',
     message: 'Which bundler should be used?',
@@ -470,32 +591,32 @@ async function chooseBundler ({bundlers, decisions}) {
 async function scaffoldBundler ({projectRoot, projectType, bundlers, dialect, decisions}) {
   const chosenBundler = await chooseBundler({bundlers, decisions});
 
-  return javascriptCore.scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
+  return scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
 }
 
 function determinePathToTemplateFile (fileName) {
-  const [, __dirname] = filedirname__default["default"]();
+  const [, __dirname] = filedirname();
 
-  return path.resolve(__dirname, '..', 'templates', fileName);
+  return resolve(__dirname, '..', 'templates', fileName);
 }
 
 const defaultBuildDirectory$2 = 'lib';
 
 async function createExample(projectRoot, projectName, dialect) {
-  return fs.promises.writeFile(
+  return promises.writeFile(
     `${projectRoot}/example.js`,
-    mustache__default["default"].render(
-      await fs.promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'),
-      {projectName: camelcase__default["default"](projectName), esm: dialect === javascriptCore.dialects.ESM}
+    mustache.render(
+      await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'),
+      {projectName: camelcase(projectName), esm: dialect === dialects$1.ESM}
     )
   );
 }
 
 async function buildDetailsForCommonJsProject({projectRoot, projectName, provideExample}) {
   await Promise.all([
-    touch__default["default"](`${projectRoot}/index.js`),
+    touch(`${projectRoot}/index.js`),
     provideExample
-      ? fs.promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase__default["default"](projectName)} = require('.');\n`)
+      ? promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)
       : Promise.resolve()
   ]);
 
@@ -512,16 +633,16 @@ async function buildDetails ({
   provideExample,
   decisions
 }) {
-  if (javascriptCore.dialects.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName, provideExample});
+  if (dialects$1.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName, provideExample});
 
-  const pathToCreatedSrcDirectory = await mkdir__default["default"](`${projectRoot}/src`);
+  const pathToCreatedSrcDirectory = await mkdir(`${projectRoot}/src`);
   const [bundlerResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: javascriptCore.projectTypes.PACKAGE}),
+    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.PACKAGE}),
     provideExample ? await createExample(projectRoot, projectName, dialect) : Promise.resolve,
-    touch__default["default"](`${pathToCreatedSrcDirectory}/index.js`)
+    touch(`${pathToCreatedSrcDirectory}/index.js`)
   ]);
 
-  return deepmerge__default["default"](
+  return deepmerge(
     bundlerResults,
     {
       devDependencies: ['rimraf'],
@@ -562,7 +683,7 @@ async function scaffoldPackageType ({
   provideExample,
   publishRegistry
 }) {
-  cliMessages.info('Scaffolding Package Details');
+  info('Scaffolding Package Details');
 
   const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
   const [detailsForBuild, publishableResults] = await Promise.all([
@@ -577,17 +698,17 @@ async function scaffoldPackageType ({
       decisions
     }),
     scaffoldPublishable({packageName, packageAccessLevel}),
-    javascriptCore.mergeIntoExistingPackageJson({
+    mergeIntoExistingPackageJson({
       projectRoot,
       config: {
-        files: ['example.js', ...javascriptCore.dialects.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
+        files: ['example.js', ...dialects$1.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
         publishConfig: {
           access: packageAccessLevel,
           ...publishRegistry && {registry: publishRegistry}
         },
         sideEffects: false,
         ...'Public' === visibility && {runkitExampleFilename: './example.js'},
-        ...javascriptCore.dialects.BABEL === dialect && {
+        ...dialects$1.BABEL === dialect && {
           main: './lib/index.js',
           module: './lib/index.mjs',
           exports: {
@@ -596,11 +717,11 @@ async function scaffoldPackageType ({
             import: './lib/index.mjs'
           }
         },
-        ...javascriptCore.dialects.ESM === dialect && {
+        ...dialects$1.ESM === dialect && {
           main: './lib/index.js',
           exports: './lib/index.js'
         },
-        ...javascriptCore.dialects.TYPESCRIPT === dialect && {
+        ...dialects$1.TYPESCRIPT === dialect && {
           main: './lib/index.js',
           module: './lib/index.mjs',
           types: './lib/index.d.ts',
@@ -614,12 +735,13 @@ async function scaffoldPackageType ({
     })
   ]);
 
-  return deepmerge__default["default"].all([
+  return deepmerge.all([
     publishableResults,
     {
       documentation: scaffoldPackageDocumentation({packageName, visibility, scope, packageManager, provideExample}),
       nextSteps: [
         {summary: 'Add the appropriate `save` flag to the installation instructions in the README'},
+        {summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'},
         {summary: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'}
       ]
     },
@@ -638,9 +760,9 @@ async function isPackage ({packageDetails: {exports, publishConfig, bin}}) {
 const defaultBuildDirectory$1 = 'public';
 
 async function scaffoldApplicationType ({projectRoot}) {
-  cliMessages.info('Scaffolding Application Details');
+  info('Scaffolding Application Details');
 
-  await javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
 
   const buildDirectory = defaultBuildDirectory$1;
 
@@ -663,9 +785,9 @@ function isApplication ({packageDetails}) {
 }
 
 async function scaffoldMonorepoType ({projectRoot}) {
-  cliMessages.info('Scaffolding Monorepo Details');
+  info('Scaffolding Monorepo Details');
 
-  await javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
 
   return {
     nextSteps: [{
@@ -689,9 +811,9 @@ async function scaffoldCliType ({
 }) {
   const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
   const [bundlerResults, publishableResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: javascriptCore.projectTypes.CLI}),
+    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.CLI}),
     scaffoldPublishable({packageName, packageAccessLevel}),
-    javascriptCore.mergeIntoExistingPackageJson({
+    mergeIntoExistingPackageJson({
       projectRoot,
       config: {
         bin: {},
@@ -704,7 +826,7 @@ async function scaffoldCliType ({
     })
   ]);
 
-  return deepmerge__default["default"].all([
+  return deepmerge.all([
     publishableResults,
     bundlerResults,
     {
@@ -718,7 +840,7 @@ async function scaffoldCliType ({
       devDependencies: ['rimraf'],
       vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
       buildDirectory: defaultBuildDirectory,
-      nextSteps: []
+      nextSteps: [{summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'}]
     }
   ]);
 }
@@ -746,7 +868,7 @@ async function scaffoldProjectType ({
   publishRegistry
 }) {
   switch (projectType) {
-    case javascriptCore.projectTypes.PACKAGE:
+    case projectTypes$1.PACKAGE:
       return scaffoldPackageType({
         projectRoot,
         projectName,
@@ -760,9 +882,9 @@ async function scaffoldProjectType ({
         provideExample,
         publishRegistry
       });
-    case javascriptCore.projectTypes.APPLICATION:
+    case projectTypes$1.APPLICATION:
       return scaffoldApplicationType({projectRoot});
-    case javascriptCore.projectTypes.CLI:
+    case projectTypes$1.CLI:
       return scaffoldCliType({
         packageName,
         visibility,
@@ -772,7 +894,7 @@ async function scaffoldProjectType ({
         decisions,
         packageBundlers
       });
-    case javascriptCore.projectTypes.MONOREPO:
+    case projectTypes$1.MONOREPO:
       return scaffoldMonorepoType({projectRoot});
     case 'Other':
       return {};
@@ -791,7 +913,7 @@ function vcsRepositoryHostedOnGithub(vcs) {
   return vcs && 'github' === vcs.host;
 }
 
-async function lifter$2 ({projectRoot, packageDetails, vcs}) {
+async function lifter$1 ({projectRoot, packageDetails, vcs}) {
   if (await isPackage({projectRoot, packageDetails})) return liftPackage$1({projectRoot, packageDetails});
   if (await isCli({projectRoot, packageDetails})) return liftCli({projectRoot, packageDetails});
 
@@ -800,7 +922,7 @@ async function lifter$2 ({projectRoot, packageDetails, vcs}) {
   if (vcsRepositoryHostedOnGithub(vcs)) {
     homepage = `https://github.com/${vcs.owner}/${vcs.name}#readme`;
 
-    await javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+    await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
   }
 
   return {homepage};
@@ -808,18 +930,22 @@ async function lifter$2 ({projectRoot, packageDetails, vcs}) {
 
 var projectTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  lift: lifter$1,
   scaffold: scaffoldProjectType,
-  test: tester$1,
-  lift: lifter$2
+  test: tester$1
 });
 
 function write ({projectRoot, config}) {
-  return configFile.write({path: projectRoot, name: 'babel', format: core.fileTypes.JSON, config});
+  return write$2({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+}
+
+function loadConfig () {
+  return load({name: 'babel'});
 }
 
 async function addIgnore ({projectRoot, ignore}) {
   if (ignore) {
-    const existingConfig = JSON.parse(await node_fs.promises.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
+    const existingConfig = await loadConfig();
 
     await write({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
   }
@@ -838,29 +964,29 @@ async function scaffoldBabel ({projectRoot, preset}) {
   };
 }
 
-async function lifter$1 ({results, projectRoot}) {
+async function lifter ({results, projectRoot}) {
   await addIgnore({ignore: results.buildDirectory, projectRoot});
 
   return {};
 }
 
 function predicate ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/.babelrc.json`);
+  return fileExists(`${projectRoot}/.babelrc.json`);
 }
 
 async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
   const shareableTsConfigPackage = `${config.scope}/tsconfig`;
 
-  await core.writeConfigFile({
+  await writeConfigFile({
     path: projectRoot,
     name: 'tsconfig',
-    format: core.fileTypes.JSON,
+    format: fileTypes.JSON,
     config: {
       $schema: 'https://json.schemastore.org/tsconfig',
       extends: shareableTsConfigPackage,
       compilerOptions: {
         rootDir: 'src',
-        ...javascriptCore.projectTypes.PACKAGE === projectType && {
+        ...projectTypes$1.PACKAGE === projectType && {
           outDir: 'lib',
           declaration: true
         }
@@ -879,9 +1005,9 @@ async function scaffoldTypescript ({config, projectType, projectRoot, testFilena
 
 function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
   switch (dialect) {
-    case javascriptCore.dialects.BABEL:
+    case dialects$1.BABEL:
       return scaffoldBabel({preset: configs.babelPreset, projectRoot});
-    case javascriptCore.dialects.TYPESCRIPT:
+    case dialects$1.TYPESCRIPT:
       return scaffoldTypescript({config: configs.typescript, projectType, projectRoot, testFilenamePattern});
     default:
       return {};
@@ -890,11 +1016,22 @@ function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilen
 
 var dialects = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  lift: lifter,
   scaffold: scaffoldDialect,
-  test: predicate,
-  lift: lifter$1
+  test: predicate
 });
 
+function buildPackageName (projectName, scope) {
+  const name = `${scope ? `@${scope}/` : ''}${projectName}`;
+
+  const {validForNewPackages, errors} = validatePackageName(name);
+
+  if (validForNewPackages) return name;
+  if (1 === errors.length && errors.includes('name cannot start with a period')) return projectName.slice(1);
+
+  throw new Error(`The package name ${name} is invalid:${EOL}\t* ${errors.join(`${EOL}\t* `)}`);
+}
+
 function buildPackageDetails ({
   packageName,
   dialect,
@@ -906,7 +1043,7 @@ function buildPackageDetails ({
     name: packageName,
     description,
     license,
-    type: javascriptCore.dialects.ESM === dialect ? 'module' : 'commonjs',
+    type: dialects$1.ESM === dialect ? 'module' : 'commonjs',
     author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
     scripts: {}
   };
@@ -914,29 +1051,33 @@ function buildPackageDetails ({
 
 async function scaffoldPackage ({
   projectRoot,
+  projectName,
+  scope,
   dialect,
-  packageName,
   license,
   author,
   description
 }) {
-  cliMessages.info('Configuring package.json');
+  info('Configuring package.json');
 
-  const packageData = await buildPackageDetails({
-    packageName,
-    dialect,
-    license,
-    author,
-    description
-  });
+  const packageName = buildPackageName(projectName, scope);
 
-  await javascriptCore.writePackageJson({projectRoot, config: packageData});
+  await writePackageJson({
+    projectRoot,
+    config: await buildPackageDetails({
+      packageName,
+      dialect,
+      license,
+      author,
+      description
+    })
+  });
 
-  return {};
+  return {packageName};
 }
 
 function sortPackageProperties (packageContents) {
-  return sortProperties__default["default"](
+  return sortProperties(
     packageContents,
     [
       'name',
@@ -986,19 +1127,19 @@ function defineVcsHostDetails (vcs, pathWithinParent) {
 }
 
 const details = {
-  [javascriptCore.packageManagers.NPM]: {
+  [packageManagers$1.NPM]: {
     installationCommand: 'install',
     installationFlags: {
-      [javascriptCore.DEV_DEPENDENCY_TYPE]: `save-${javascriptCore.DEV_DEPENDENCY_TYPE}`,
-      [javascriptCore.PROD_DEPENDENCY_TYPE]: `save-${javascriptCore.PROD_DEPENDENCY_TYPE}`,
+      [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
+      [PROD_DEPENDENCY_TYPE]: `save-${PROD_DEPENDENCY_TYPE}`,
       exact: 'save-exact'
     }
   },
-  [javascriptCore.packageManagers.YARN]: {
+  [packageManagers$1.YARN]: {
     installationCommand: 'add',
     installationFlags: {
-      [javascriptCore.DEV_DEPENDENCY_TYPE]: javascriptCore.DEV_DEPENDENCY_TYPE,
-      [javascriptCore.PROD_DEPENDENCY_TYPE]: javascriptCore.PROD_DEPENDENCY_TYPE,
+      [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
+      [PROD_DEPENDENCY_TYPE]: PROD_DEPENDENCY_TYPE,
       exact: 'exact'
     }
   }
@@ -1016,19 +1157,31 @@ function getExactFlag(manager) {
   return details[manager].installationFlags.exact;
 }
 
-async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = javascriptCore.packageManagers.NPM) {
+async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
   if (dependencies.length) {
-    cliMessages.info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
+    info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
 
-    await execa__default["default"](
+    await execa(
       `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${
         getInstallationCommandFor(packageManager)
       } ${[...new Set(dependencies)].join(' ')} --${getDependencyTypeFlag(packageManager, dependenciesType)}${
-        javascriptCore.DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
+        DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
       }`,
       {shell: true, cwd: projectRoot}
     );
-  } else cliMessages.warn(`No ${dependenciesType} dependencies to install`);
+  } else warn(`No ${dependenciesType} dependencies to install`);
+}
+
+async function processDependencies ({dependencies, devDependencies, projectRoot, packageManager}) {
+  info('Processing dependencies');
+
+  try {
+    await install$1(dependencies || [], PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await install$1(devDependencies || [], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+  } catch (e) {
+    error('Failed to update dependencies');
+    error(e, {level: 'secondary'});
+  }
 }
 
 function projectWillBeTested(scripts) {
@@ -1064,100 +1217,30 @@ async function liftPackage ({
   vcs,
   pathWithinParent
 }) {
-  if (scripts || tags) {
-    cliMessages.info('Updating `package.json`', {level: 'secondary'});
-
-    const pathToPackageJson = `${projectRoot}/package.json`;
+  info('Updating `package.json`', {level: 'secondary'});
 
-    const existingPackageJsonContents = JSON.parse(await fs.promises.readFile(pathToPackageJson, 'utf8'));
-
-    await javascriptCore.writePackageJson({
-      projectRoot,
-      config: sortPackageProperties({
-        ...existingPackageJsonContents,
-        ...defineVcsHostDetails(vcs, pathWithinParent),
-        scripts: liftScripts({
-          existingScripts: existingPackageJsonContents.scripts,
-          scripts
-        }),
-        ...tags && {
-          keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
-        }
-      })
-    });
-  }
-
-  cliMessages.info('Installing dependencies');
-
-  try {
-    await install$1(dependencies || [], javascriptCore.PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
-    await install$1([...devDependencies || []], javascriptCore.DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
-  } catch (e) {
-    cliMessages.error('Failed to install dependencies');
-    cliMessages.error(e, {level: 'secondary'});
-  }
-}
-
-function determineLockfilePathFor (packageManager) {
-  const lockfilePaths = {
-    [javascriptCore.packageManagers.NPM]: 'package-lock.json',
-    [javascriptCore.packageManagers.YARN]: 'yarn.lock'
-  };
-
-  return lockfilePaths[packageManager];
-}
-
-function npmIsUsed ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/${determineLockfilePathFor(javascriptCore.packageManagers.NPM)}`);
-}
-
-function yarnIsUsed ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/${determineLockfilePathFor(javascriptCore.packageManagers.YARN)}`);
-}
-
-async function jsPackageManagerIsUsed ({projectRoot}) {
-  const [npmFound, yarnFound] = await Promise.all([
-    npmIsUsed({projectRoot}),
-    yarnIsUsed({projectRoot})
-  ]);
-
-  return npmFound || yarnFound;
-}
-
-async function liftCorepack () {
-  await execa__default["default"]('corepack', ['use', 'npm@latest']);
-}
-
-async function lifter () {
-  await liftCorepack();
-
-  return {};
-}
-
-async function resolvePackageManager ({projectRoot, packageManager}) {
-  if (packageManager) return packageManager;
-
-  if (await npmIsUsed({projectRoot})) {
-    return javascriptCore.packageManagers.NPM;
-  }
+  const existingPackageJsonContents = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf-8'));
 
-  if (await yarnIsUsed({projectRoot})) {
-    return javascriptCore.packageManagers.YARN;
-  }
+  await writePackageJson({
+    projectRoot,
+    config: sortPackageProperties({
+      ...existingPackageJsonContents,
+      ...defineVcsHostDetails(vcs, pathWithinParent),
+      scripts: liftScripts({
+        existingScripts: existingPackageJsonContents.scripts,
+        scripts
+      }),
+      ...tags && {
+        keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
+      }
+    })
+  });
 
-  throw new Error('Package-manager could not be determined');
+  await processDependencies({dependencies, devDependencies, projectRoot, packageManager});
 }
 
-var packageManagers = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  test: jsPackageManagerIsUsed,
-  lift: lifter,
-  determineCurrent: resolvePackageManager,
-  defineLockfilePath: determineLockfilePathFor
-});
-
-async function lift ({projectRoot, vcs, results, pathWithinParent}) {
-  cliMessages.info('Lifting JavaScript-specific details');
+async function lift ({projectRoot, vcs, results, pathWithinParent, enhancers = {}, configs = {}}) {
+  info('Lifting JavaScript-specific details');
 
   const {
     scripts,
@@ -1169,27 +1252,29 @@ async function lift ({projectRoot, vcs, results, pathWithinParent}) {
 
   const [packageManager, packageContents] = await Promise.all([
     resolvePackageManager({projectRoot, packageManager: manager}),
-    node_fs.promises.readFile(`${projectRoot}/package.json`, 'utf8')
+    promises$1.readFile(`${projectRoot}/package.json`, 'utf8')
   ]);
 
-  const enhancerResults = await core.applyEnhancers({
+  const enhancerResults = await applyEnhancers({
     results,
-    enhancers: [
-      huskyPlugin__namespace,
+    enhancers: {
+      ...enhancers,
+      huskyPlugin,
       enginesEnhancer,
       coveragePlugin,
-      commitConventionPlugin__namespace,
+      commitConventionPlugin,
       dialects,
       codeStylePlugin,
       npmConfigPlugin,
       projectTypes,
-      packageManagers
-    ],
-    options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents)}
+      packageManagers,
+      registriesPlugin
+    },
+    options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents), configs}
   });
 
   await liftPackage(
-    deepmerge__default["default"].all([
+    deepmerge.all([
       {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
       enhancerResults
     ])
@@ -1198,109 +1283,77 @@ async function lift ({projectRoot, vcs, results, pathWithinParent}) {
   return enhancerResults;
 }
 
-const pluginSchema = joi__default["default"].object({scaffolder: joi__default["default"].func().arity(1).required()});
-const pluginMapSchema = joi__default["default"].object().pattern(joi__default["default"].string(), pluginSchema);
+const scopeBasedConfigSchema = joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()});
+
+const nameBasedConfigSchema = joi.object({
+  packageName: joi.string().required(),
+  name: joi.string().required()
+});
 
-const packageBundlersSchema = pluginMapSchema.default({});
+const registriesSchema = joi.object().pattern(joi.string(), joi.string().uri()).default({});
 
-const applicationTypesSchema = pluginMapSchema.default({});
+const visibilitySchema = joi.string().valid('Public', 'Private').required();
 
-const packageTypesSchema = pluginMapSchema.default({});
+const projectNameSchema = joi.string().regex(/^@\w*\//, {invert: true}).required();
 
-const monorepoTypesSchema = pluginMapSchema.default({});
+const vcsSchema = joi.object({
+  host: joi.string().required(),
+  owner: joi.string().required(),
+  name: joi.string().required()
+});
 
 function validate(options) {
-  const schema = joi__default["default"].object().required()
-    .keys({
-      projectRoot: joi__default["default"].string().required(),
-      projectName: joi__default["default"].string().regex(/^@\w*\//, {invert: true}).required(),
-      visibility: joi__default["default"].string().valid('Public', 'Private').required(),
-      license: joi__default["default"].string().required(),
-      description: joi__default["default"].string(),
-      pathWithinParent: joi__default["default"].string()
-    })
-    .keys({
-      vcs: joi__default["default"].object({
-        host: joi__default["default"].string().required(),
-        owner: joi__default["default"].string().required(),
-        name: joi__default["default"].string().required()
-      })
-    })
-    .keys({
-      configs: joi__default["default"].object({
-        eslint: joi__default["default"].object({scope: joi__default["default"].string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        typescript: joi__default["default"].object({scope: joi__default["default"].string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        prettier: joi__default["default"].object({scope: joi__default["default"].string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        commitlint: joi__default["default"].object({
-          packageName: joi__default["default"].string().required(),
-          name: joi__default["default"].string().required()
-        }),
-        babelPreset: joi__default["default"].object({
-          packageName: joi__default["default"].string().required(),
-          name: joi__default["default"].string().required()
-        }),
-        remark: joi__default["default"].string()
-      }).default({})
-    })
-    .keys({
-      overrides: joi__default["default"].object({
-        npmAccount: joi__default["default"].string(),
-        author: joi__default["default"].object({
-          name: joi__default["default"].string().required(),
-          email: joi__default["default"].string().email(),
-          url: joi__default["default"].string().uri()
-        })
-      }).default({})
-    })
-    .keys({
-      ciServices: joi__default["default"].object().pattern(/^/, joi__default["default"].object({
-        scaffolder: joi__default["default"].func().arity(1).required(),
-        public: joi__default["default"].boolean(),
-        private: joi__default["default"].boolean()
-      })).default({})
-    })
-    .keys({
-      hosts: joi__default["default"].object().pattern(/^/, joi__default["default"].object({
-        scaffolder: joi__default["default"].func().arity(1).required(),
-        projectTypes: joi__default["default"].array().items(joi__default["default"].string().valid('static', 'node')).default([])
-      })).default({})
-    })
-    .keys({
-      applicationTypes: applicationTypesSchema,
-      packageTypes: packageTypesSchema,
-      monorepoTypes: monorepoTypesSchema
-    })
-    .keys({
-      unitTestFrameworks: unitTestFrameworksSchema,
-      packageBundlers: packageBundlersSchema
-    })
-    .keys({
-      decisions: joi__default["default"].object()
-    })
-    .keys({registries: joi__default["default"].object().pattern(joi__default["default"].string(), joi__default["default"].string().uri()).default({})});
+  const schema = joi.object({
+    projectRoot: joi.string().required(),
+    projectName: projectNameSchema,
+    visibility: visibilitySchema,
+    license: joi.string().required(),
+    description: joi.string(),
+    pathWithinParent: joi.string(),
+    decisions: joi.object(),
+    vcs: vcsSchema,
+    configs: joi.object({
+      eslint: scopeBasedConfigSchema,
+      typescript: scopeBasedConfigSchema,
+      prettier: scopeBasedConfigSchema,
+      commitlint: nameBasedConfigSchema,
+      babelPreset: nameBasedConfigSchema,
+      remark: joi.string(),
+      registries: registriesSchema
+    }).default({}),
+    plugins: {
+      unitTestFrameworks: pluginsSchema,
+      packageBundlers: pluginsSchema,
+      applicationTypes: pluginsSchema,
+      packageTypes: pluginsSchema,
+      monorepoTypes: pluginsSchema,
+      hosts: pluginsSchema,
+      ciServices: pluginsSchema
+    }
+  }).required();
 
-  return core.validateOptions(schema, options);
+  return validateOptions(schema, options);
 }
 
 function buildDialectChoices ({babelPreset, typescript}) {
   return [
-    {name: 'Common JS (no transpilation)', value: javascriptCore.dialects.COMMON_JS, short: 'cjs'},
-    ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: javascriptCore.dialects.BABEL, short: 'modern'}] : [],
-    {name: 'ESM-only (no transpilation)', value: javascriptCore.dialects.ESM, short: 'esm'},
-    ...typescript ? [{name: 'TypeScript', value: javascriptCore.dialects.TYPESCRIPT, short: 'ts'}] : []
+    {name: 'Common JS (no transpilation)', value: dialects$1.COMMON_JS, short: 'cjs'},
+    ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: dialects$1.BABEL, short: 'modern'}] : [],
+    {name: 'ESM-only (no transpilation)', value: dialects$1.ESM, short: 'esm'},
+    ...typescript ? [{name: 'TypeScript', value: dialects$1.TYPESCRIPT, short: 'ts'}] : []
   ];
 }
 
 function projectIsCLI(answers) {
-  return javascriptCore.projectTypes.CLI === answers[questionNames$1.PROJECT_TYPE];
+  return projectTypes$1.CLI === answers[questionNames$1.PROJECT_TYPE];
 }
 
 function projectIsPackage(answers) {
-  return javascriptCore.projectTypes.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
+  return projectTypes$1.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
 }
 
 function projectIsApplication(answers) {
-  return javascriptCore.projectTypes.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
+  return projectTypes$1.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
 }
 
 function packageShouldBeScoped(visibility, answers) {
@@ -1320,8 +1373,8 @@ function scopePromptShouldBePresentedFactory(visibility) {
 }
 
 function lintingPromptShouldBePresented({
-  [languageScaffolderPrompts.questionNames.UNIT_TESTS]: unitTested,
-  [languageScaffolderPrompts.questionNames.INTEGRATION_TESTS]: integrationTested
+  [questionNames$2.UNIT_TESTS]: unitTested,
+  [questionNames$2.INTEGRATION_TESTS]: integrationTested
 }) {
   return !unitTested && !integrationTested;
 }
@@ -1357,7 +1410,6 @@ function authorQuestions({name, email, url}) {
 }
 
 async function prompt(
-  {npmAccount, author},
   ciServices,
   hosts,
   visibility,
@@ -1366,23 +1418,23 @@ async function prompt(
   configs,
   pathWithinParent
 ) {
-  const npmConf = npmConf__default["default"]();
+  const npmConf$1 = npmConf();
 
   let maybeLoggedInNpmUsername;
   try {
-    maybeLoggedInNpmUsername = (await execa__default["default"]('npm', ['whoami'])).stdout;
+    maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
   } catch (failedExecutionResult) {
     if (!decisions[questionNames$1.SCOPE]) {
-      cliMessages.warn('No logged in user found with `npm whoami`. Login with `npm login` '
+      warn('No logged in user found with `npm whoami`. Login with `npm login` '
         + 'to use your npm account name as the package scope default.');
     }
   }
 
   const {
-    [languageScaffolderPrompts.questionNames.UNIT_TESTS]: unitTested,
-    [languageScaffolderPrompts.questionNames.INTEGRATION_TESTS]: integrationTested,
+    [questionNames$2.UNIT_TESTS]: unitTested,
+    [questionNames$2.INTEGRATION_TESTS]: integrationTested,
     [questionNames$1.PROJECT_TYPE]: projectType,
-    [languageScaffolderPrompts.questionNames.CI_SERVICE]: ci,
+    [questionNames$2.CI_SERVICE]: ci,
     [questionNames$1.HOST]: chosenHost,
     [questionNames$1.SCOPE]: scope$1,
     [questionNames$1.NODE_VERSION_CATEGORY]: nodeVersionCategory,
@@ -1393,7 +1445,7 @@ async function prompt(
     [questionNames$1.PROVIDE_EXAMPLE]: provideExample,
     [questionNames$1.PACKAGE_MANAGER]: packageManager,
     [questionNames$1.DIALECT]: dialect
-  } = await overridablePrompts.prompt([
+  } = await prompt$1([
     {
       name: questionNames$1.DIALECT,
       message: 'Which JavaScript dialect should this project follow?',
@@ -1412,15 +1464,15 @@ async function prompt(
       name: questionNames$1.PACKAGE_MANAGER,
       message: 'Which package manager will be used with this project?',
       type: 'list',
-      choices: Object.values(javascriptCore.packageManagers),
-      default: javascriptCore.packageManagers.NPM
+      choices: Object.values(packageManagers$1),
+      default: packageManagers$1.NPM
     },
     {
       name: questionNames$1.PROJECT_TYPE,
       message: 'What type of JavaScript project is this?',
       type: 'list',
-      choices: [...Object.values(javascriptCore.projectTypes), new overridablePrompts.Separator(), 'Other'],
-      default: javascriptCore.projectTypes.PACKAGE
+      choices: [...Object.values(projectTypes$1), 'Other'],
+      default: projectTypes$1.PACKAGE
     },
     ...'Private' === visibility ? [] : [{
       name: questionNames$1.SHOULD_BE_SCOPED,
@@ -1434,14 +1486,14 @@ async function prompt(
       message: 'What is the scope?',
       when: scopePromptShouldBePresentedFactory(visibility),
       validate: scope(visibility),
-      default: npmAccount || maybeLoggedInNpmUsername
+      default: maybeLoggedInNpmUsername
     },
-    ...authorQuestions(author || {
-      name: npmConf.get('init.author.name'),
-      email: npmConf.get('init.author.email'),
-      url: npmConf.get('init.author.url')
+    ...authorQuestions({
+      name: npmConf$1.get('init.author.name'),
+      email: npmConf$1.get('init.author.email'),
+      url: npmConf$1.get('init.author.url')
     }),
-    ...languageScaffolderPrompts.questions(({vcs, ciServices, visibility, pathWithinParent})),
+    ...questions(({vcs, ciServices, pathWithinParent})),
     {
       name: questionNames$1.CONFIGURE_LINTING,
       message: 'Will there be source code that should be linted?',
@@ -1459,7 +1511,7 @@ async function prompt(
       type: 'list',
       message: 'Where will the application be hosted?',
       when: projectIsApplication,
-      choices: [...Object.keys(hosts), new overridablePrompts.Separator(), 'Other']
+      choices: [...Object.keys(hosts), 'Other']
     }
   ], decisions);
 
@@ -1497,10 +1549,14 @@ $ ${packageManager} test
   };
 }
 
+function buildBadgesDetails (contributors) {
+  return deepmerge.all(contributors).badges;
+}
+
 async function determineLatestVersionOf(nodeVersionCategory) {
-  cliMessages.info('Determining version of node', {level: 'secondary'});
+  info('Determining version of node', {level: 'secondary'});
 
-  const {stdout: nvmLsOutput} = await execa__default["default"](
+  const {stdout: nvmLsOutput} = await execa(
     `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
     {shell: true}
   );
@@ -1512,9 +1568,9 @@ async function determineLatestVersionOf(nodeVersionCategory) {
 }
 
 function install(nodeVersionCategory) {
-  cliMessages.info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
+  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
 
-  const subprocess = execa__default["default"]('. ~/.nvm/nvm.sh && nvm install', {shell: true});
+  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
   subprocess.stdout.pipe(process.stdout);
   return subprocess;
 }
@@ -1523,11 +1579,11 @@ async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
   if (!nodeVersionCategory) return undefined;
 
   const lowerCaseCategory = nodeVersionCategory.toLowerCase();
-  cliMessages.info(`Configuring ${lowerCaseCategory} version of node`);
+  info(`Configuring ${lowerCaseCategory} version of node`);
 
   const version = await determineLatestVersionOf(nodeVersionCategory);
 
-  await node_fs.promises.writeFile(`${projectRoot}/.nvmrc`, version);
+  await promises$1.writeFile(`${projectRoot}/.nvmrc`, version);
 
   await install(nodeVersionCategory);
 
@@ -1535,11 +1591,7 @@ async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
 }
 
 function nvmIsUsed ({projectRoot}) {
-  return core.fileExists(`${projectRoot}/.nvmrc`);
-}
-
-function buildBadgesDetails (contributors) {
-  return deepmerge__default["default"].all(contributors).badges;
+  return fileExists(`${projectRoot}/.nvmrc`);
 }
 
 function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
@@ -1549,25 +1601,14 @@ function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
   };
 }
 
-function buildPackageName (projectName, scope) {
-  const name = `${scope ? `@${scope}/` : ''}${projectName}`;
-
-  const {validForNewPackages, errors} = validatePackageName__default["default"](name);
-
-  if (validForNewPackages) return name;
-  if (1 === errors.length && errors.includes('name cannot start with a period')) return projectName.slice(1);
-
-  throw new Error(`The package name ${name} is invalid:${os.EOL}\t* ${errors.join(`${os.EOL}\t* `)}`);
-}
-
 async function chooseProjectTypePlugin ({types, projectType, decisions}) {
   if (!Object.keys(types).length) return 'Other';
 
-  const answers = await overridablePrompts.prompt([{
+  const answers = await prompt$1([{
     name: questionNames$1.PROJECT_TYPE_CHOICE,
     type: 'list',
     message: `What type of ${projectType} is this?`,
-    choices: [...Object.keys(types), new overridablePrompts.Separator(), 'Other']
+    choices: [...Object.keys(types), 'Other']
   }], decisions);
 
   return answers[questionNames$1.PROJECT_TYPE_CHOICE];
@@ -1591,7 +1632,7 @@ async function scaffoldProjectTypePlugin ({
 
   const chosenType = await chooseProjectTypePlugin({types: pluginsForProjectType, decisions, projectType});
 
-  return javascriptCore.scaffoldChoice(
+  return scaffoldChoice(
     pluginsForProjectType,
     chosenType,
     {projectRoot, projectName, packageName, packageManager, scope, tests, dialect}
@@ -1620,46 +1661,7 @@ async function scaffoldTesting ({
     })
     : {};
 
-  return deepmerge__default["default"]({devDependencies: [...(unit || integration) ? ['@travi/any'] : []], eslint: {}}, unitResults);
-}
-
-function buildAllowedHostsList ({packageManager, registries}) {
-  return [
-    ...(!registries || (registries && !registries.registry)) ? [packageManager] : [],
-    ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
-  ];
-}
-
-const lockfileLintSupportedPackageManagers = [javascriptCore.packageManagers.NPM, javascriptCore.packageManagers.YARN];
-
-function lockfileLintSupports(packageManager) {
-  return lockfileLintSupportedPackageManagers.includes(packageManager);
-}
-
-async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
-  if (!lockfileLintSupports(packageManager)) {
-    throw new Error(
-      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
-      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
-    );
-  }
-
-  await configFile.write({
-    name: 'lockfile-lint',
-    format: core.fileTypes.JSON,
-    path: projectRoot,
-    config: {
-      path: determineLockfilePathFor(packageManager),
-      type: packageManager,
-      'validate-https': true,
-      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
-    }
-  });
-
-  return {
-    devDependencies: ['lockfile-lint'],
-    scripts: {'lint:lockfile': 'lockfile-lint'}
-  };
+  return deepmerge({devDependencies: [...(unit || integration) ? ['@travi/any'] : []], eslint: {}}, unitResults);
 }
 
 async function scaffoldLinting ({projectRoot, packageManager, registries}) {
@@ -1690,14 +1692,14 @@ async function scaffoldVerification({
       pathWithinParent
     }),
     scaffoldLinting({projectRoot, packageManager, registries, vcs, pathWithinParent}),
-    huskyPlugin.scaffold({projectRoot, packageManager, pathWithinParent})
+    scaffold$3({projectRoot, packageManager, pathWithinParent})
   ]);
 
-  return deepmerge__default["default"].all([testingResults, lintingResults, huskyResults]);
+  return deepmerge.all([testingResults, lintingResults, huskyResults]);
 }
 
 async function scaffolder (options) {
-  cliMessages.info('Initializing JavaScript project');
+  info('Initializing JavaScript project');
 
   const {
     projectRoot,
@@ -1707,17 +1709,17 @@ async function scaffolder (options) {
     vcs,
     description,
     configs,
-    overrides,
-    ciServices,
-    hosts,
-    applicationTypes,
-    packageTypes,
-    packageBundlers,
-    monorepoTypes,
     decisions,
-    unitTestFrameworks,
     pathWithinParent,
-    registries
+    plugins: {
+      applicationTypes,
+      packageTypes,
+      monorepoTypes,
+      packageBundlers,
+      unitTestFrameworks,
+      hosts,
+      ciServices
+    }
   } = validate(options);
 
   const {
@@ -1732,15 +1734,15 @@ async function scaffolder (options) {
     provideExample,
     packageManager,
     dialect
-  } = await prompt(overrides, ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
+  } = await prompt(ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
 
-  cliMessages.info('Writing project files', {level: 'secondary'});
+  info('Writing project files', {level: 'secondary'});
 
-  const packageName = buildPackageName(projectName, scope);
-  await scaffoldPackage({
+  const {packageName} = await scaffoldPackage({
     projectRoot,
+    projectName,
+    scope,
     dialect,
-    packageName,
     license,
     author,
     description
@@ -1754,15 +1756,15 @@ async function scaffolder (options) {
     visibility,
     applicationTypes,
     packageTypes,
-    packageBundlers,
     monorepoTypes,
+    packageBundlers,
     scope,
     tests,
     vcs,
     decisions,
     dialect,
     provideExample,
-    publishRegistry: registries.publish
+    publishRegistry: configs.registries.publish
   });
   const verificationResults = await scaffoldVerification({
     projectRoot,
@@ -1770,7 +1772,7 @@ async function scaffolder (options) {
     visibility,
     packageManager,
     vcs,
-    registries,
+    registries: configs.registries,
     tests,
     unitTestFrameworks,
     decisions,
@@ -1778,7 +1780,7 @@ async function scaffolder (options) {
   });
   const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([
     scaffoldNodeVersion({projectRoot, nodeVersionCategory}),
-    scaffoldNpmConfig({projectType, projectRoot, registries}),
+    scaffoldNpmConfig({projectType, projectRoot}),
     scaffoldDialect({
       dialect,
       configs,
@@ -1799,20 +1801,20 @@ async function scaffolder (options) {
     tests,
     decisions,
     plugins: {
-      [javascriptCore.projectTypes.PACKAGE]: packageTypes,
-      [javascriptCore.projectTypes.APPLICATION]: applicationTypes,
-      [javascriptCore.projectTypes.MONOREPO]: monorepoTypes
+      [projectTypes$1.PACKAGE]: packageTypes,
+      [projectTypes$1.APPLICATION]: applicationTypes,
+      [projectTypes$1.MONOREPO]: monorepoTypes
     }
   });
-  const mergedContributions = deepmerge__default["default"].all([
+  const mergedContributions = deepmerge.all([
     ...(await Promise.all([
-      javascriptCore.scaffoldChoice(
+      scaffoldChoice(
         hosts,
         chosenHost,
         {buildDirectory: `./${projectTypeResults.buildDirectory}`, projectRoot, projectName, nodeVersion}
       ),
-      javascriptCore.scaffoldChoice(ciServices, ci, {projectRoot, vcs, visibility, projectType, projectName, nodeVersion, tests}),
-      commitConventionPlugin.scaffold({projectRoot, projectType, configs, pathWithinParent})
+      scaffoldChoice(ciServices, ci, {projectRoot, vcs, visibility, projectType, projectName, nodeVersion, tests}),
+      scaffold$4({projectRoot, projectType, configs, pathWithinParent})
     ])),
     projectTypeResults,
     verificationResults,
@@ -1823,7 +1825,7 @@ async function scaffolder (options) {
   ]);
 
   const liftResults = await lift({
-    results: deepmerge__default["default"]({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
+    results: deepmerge({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
     projectRoot,
     configs,
     vcs,
@@ -1849,16 +1851,12 @@ async function tester ({projectRoot}) {
 
   const jsProjectFound = nvmFound || jsPackageManagerFound;
 
-  if (jsProjectFound) cliMessages.info('JavaScript Project Detected');
+  if (jsProjectFound) info('JavaScript Project Detected');
 
   return jsProjectFound;
 }
 
-const questionNames = {...languageScaffolderPrompts.questionNames, ...questionNames$1};
+const questionNames = {...questionNames$2, ...questionNames$1};
 
-exports.lift = lift;
-exports.questionNames = questionNames;
-exports.scaffold = scaffolder;
-exports.scaffoldUnitTesting = scaffoldUnitTesting;
-exports.test = tester;
+export { lift, questionNames, scaffolder as scaffold, scaffoldUnitTesting, tester as test };
 //# sourceMappingURL=index.js.map