@form8ion/javascript 15.1.0 → 15.1.2

package/lib/index.js

@@ -4,8 +4,8 @@ import { fileTypes, fileExists, optionsSchemas, validateOptions, loadConfigFile,
 import { scaffoldChoice, dialects as dialects$1, projectTypes as projectTypes$1, packageManagers as packageManagers$1, writePackageJson, PROD_DEPENDENCY_TYPE, DEV_DEPENDENCY_TYPE, mergeIntoExistingPackageJson } 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 } from '@form8ion/config-file';
+import { scaffold, lift as lift$2 } from '@form8ion/codecov';
+import { write as write$1 } from '@form8ion/config-file';
 import { warn, info, error } from '@travi/cli-messages';
 import { promises } from 'node:fs';
 import * as huskyPlugin from '@form8ion/husky';
@@ -42,8 +42,8 @@ const questionNames$1 = {
   DIALECT: 'dialect'
 };
 
-async function scaffoldC8 ({projectRoot}) {
-  await write$2({
+async function scaffoldC8({projectRoot}) {
+  await write$1({
     name: 'c8',
     format: fileTypes.JSON,
     path: projectRoot,
@@ -60,15 +60,15 @@ async function scaffoldC8 ({projectRoot}) {
   };
 }
 
-async function scaffoldCoverage ({projectRoot, vcs, visibility, pathWithinParent}) {
+async function scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent}) {
   return deepmerge(await scaffoldC8({projectRoot}), await scaffold({vcs, visibility, pathWithinParent}));
 }
 
-function nycIsConfigured ({projectRoot}) {
+function nyvInUse({projectRoot}) {
   return fileExists(`${projectRoot}/.nycrc`);
 }
 
-async function removeNyc ({projectRoot}) {
+async function removeNyc({projectRoot}) {
   await Promise.all([
     promises.unlink(`${projectRoot}/.nycrc`),
     promises.rm(`${projectRoot}/.nyc_output`, {recursive: true, force: true})
@@ -83,10 +83,10 @@ async function removeNyc ({projectRoot}) {
   };
 }
 
-async function lift$2({projectRoot, packageManager, vcs}) {
-  const codecovResults = await lift$3({projectRoot, packageManager, vcs});
+async function lift$1({projectRoot, packageManager, vcs}) {
+  const codecovResults = await lift$2({projectRoot, packageManager, vcs});
 
-  if (await nycIsConfigured({projectRoot})) {
+  if (await nyvInUse({projectRoot})) {
     const [c8Results, nycResults] = await Promise.all([
       scaffoldC8({projectRoot}),
       removeNyc({projectRoot})
@@ -109,24 +109,24 @@ async function lift$2({projectRoot, packageManager, vcs}) {
   return codecovResults;
 }
 
-function c8IsConfigured ({projectRoot}) {
+function c8InUse({projectRoot}) {
   return fileExists(`${projectRoot}/.c8rc.json`);
 }
 
-async function tester$5 ({projectRoot}) {
-  const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({projectRoot}), nycIsConfigured({projectRoot})]);
+async function testCoverageBeingCollected({projectRoot}) {
+  const [c8Exists, nycExists] = await Promise.all([c8InUse({projectRoot}), nyvInUse({projectRoot})]);
 
   return c8Exists || nycExists;
 }
 
 var coveragePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lift$2,
+  lift: lift$1,
   scaffold: scaffoldCoverage,
-  test: tester$5
+  test: testCoverageBeingCollected
 });
 
-async function chooseFramework ({frameworks, decisions}) {
+async function gatherUnitTestingInput({frameworks, decisions}) {
   if (!Object.keys(frameworks).length) return 'Other';
 
   const answers = await prompt$1([{
@@ -141,10 +141,18 @@ async function chooseFramework ({frameworks, decisions}) {
 
 const pluginsSchema = joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});
 
-async function scaffoldUnitTesting ({projectRoot, frameworks, decisions, visibility, vcs, pathWithinParent, dialect}) {
+async function scaffoldUnitTesting({
+  projectRoot,
+  frameworks,
+  decisions,
+  visibility,
+  vcs,
+  pathWithinParent,
+  dialect
+}) {
   const validatedFrameworks = validateOptions(pluginsSchema, frameworks);
   const [framework, coverage] = await Promise.all([
-    chooseFramework({frameworks: validatedFrameworks, decisions})
+    gatherUnitTestingInput({frameworks: validatedFrameworks, decisions})
       .then(chosenFramework => scaffoldChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
     scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent})
   ]);
@@ -208,7 +216,7 @@ function validate(options) {
   return validateOptions(schema, options);
 }
 
-function buildDialectChoices ({babelPreset, typescript}) {
+function gatherDialectInput({babelPreset, typescript}) {
   return [
     {name: 'Common JS (no transpilation)', value: dialects$1.COMMON_JS, short: 'cjs'},
     ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: dialects$1.BABEL, short: 'modern'}] : [],
@@ -221,11 +229,11 @@ function projectIsCLI(answers) {
   return projectTypes$1.CLI === answers[questionNames$1.PROJECT_TYPE];
 }
 
-function projectIsPackage(answers) {
+function projectIsPackage$1(answers) {
   return projectTypes$1.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
 }
 
-function projectIsApplication(answers) {
+function projectIsApplication$1(answers) {
   return projectTypes$1.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
 }
 
@@ -234,7 +242,7 @@ function packageShouldBeScoped(visibility, answers) {
 }
 
 function willBePublishedToNpm(answers) {
-  return projectIsPackage(answers) || projectIsCLI(answers);
+  return projectIsPackage$1(answers) || projectIsCLI(answers);
 }
 
 function shouldBeScopedPromptShouldBePresented(answers) {
@@ -323,7 +331,7 @@ async function prompt(
       name: questionNames$1.DIALECT,
       message: 'Which JavaScript dialect should this project follow?',
       type: 'list',
-      choices: buildDialectChoices(configs),
+      choices: gatherDialectInput(configs),
       default: 'babel'
     },
     ...pathWithinParent ? [] : [{
@@ -377,13 +385,13 @@ async function prompt(
       name: questionNames$1.PROVIDE_EXAMPLE,
       message: 'Should an example be provided in the README?',
       type: 'confirm',
-      when: projectIsPackage
+      when: projectIsPackage$1
     },
     {
       name: questionNames$1.HOST,
       type: 'list',
       message: 'Where will the application be hosted?',
-      when: projectIsApplication,
+      when: projectIsApplication$1,
       choices: [...Object.keys(hosts), 'Other']
     }
   ], decisions);
@@ -403,28 +411,28 @@ async function prompt(
   };
 }
 
-function write$1 ({projectRoot, config}) {
-  return write$2({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+function writeBabelConfig({projectRoot, config}) {
+  return write$1({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
 }
 
-function loadConfig ({projectRoot}) {
+function loadBabelConfig({projectRoot}) {
   return loadConfigFile({path: projectRoot, name: '.babelrc', format: fileTypes.JSON});
 }
 
-async function addIgnore ({projectRoot, ignore}) {
+async function addIgnores({projectRoot, ignore}) {
   if (ignore) {
-    const existingConfig = await loadConfig({projectRoot});
+    const existingConfig = await loadBabelConfig({projectRoot});
 
-    await write$1({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
+    await writeBabelConfig({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
   }
 }
 
-async function scaffoldBabel ({projectRoot, preset}) {
+async function scaffoldBabel({projectRoot, preset}) {
   if (!preset) {
     throw new Error('No babel preset provided. Cannot configure babel transpilation');
   }
 
-  await write$1({projectRoot, config: {presets: [preset.name]}});
+  await writeBabelConfig({projectRoot, config: {presets: [preset.name]}});
 
   return {
     dependencies: {javascript: {development: ['@babel/register', preset.packageName]}},
@@ -432,17 +440,17 @@ async function scaffoldBabel ({projectRoot, preset}) {
   };
 }
 
-async function lifter$5 ({results, projectRoot}) {
-  await addIgnore({ignore: results.buildDirectory, projectRoot});
+async function liftBabel({results, projectRoot}) {
+  await addIgnores({ignore: results.buildDirectory, projectRoot});
 
   return {};
 }
 
-function predicate ({projectRoot}) {
+function babelIsInUse({projectRoot}) {
   return fileExists(`${projectRoot}/.babelrc.json`);
 }
 
-async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
+async function scaffoldTypescript({config, projectType, projectRoot, testFilenamePattern}) {
   const shareableTsConfigPackage = `${config.scope}/tsconfig`;
 
   await writeConfigFile({
@@ -471,7 +479,7 @@ async function scaffoldTypescript ({config, projectType, projectRoot, testFilena
   };
 }
 
-function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
+function scaffoldDialect({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
   switch (dialect) {
     case dialects$1.BABEL:
       return scaffoldBabel({preset: configs.babelPreset, projectRoot});
@@ -484,12 +492,12 @@ function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilen
 
 var dialects = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter$5,
+  lift: liftBabel,
   scaffold: scaffoldDialect,
-  test: predicate
+  test: babelIsInUse
 });
 
-async function writeNpmConfig ({projectRoot, config}) {
+async function writeNpmConfig({projectRoot, config}) {
   await promises.writeFile(`${projectRoot}/.npmrc`, stringify(config));
 }
 
@@ -497,7 +505,7 @@ function projectWillNotBeConsumed(projectType) {
   return projectTypes$1.APPLICATION === projectType || projectTypes$1.CLI === projectType;
 }
 
-async function scaffoldNpmConfig ({projectRoot, projectType}) {
+async function scaffoldNpmConfiguration({projectRoot, projectType}) {
   await writeNpmConfig({
     projectRoot,
     config: {'update-notifier': false, ...projectWillNotBeConsumed(projectType) && {'save-exact': true}}
@@ -506,11 +514,11 @@ async function scaffoldNpmConfig ({projectRoot, projectType}) {
   return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
 }
 
-function tester$4 ({projectRoot}) {
+function npmConfigExists({projectRoot}) {
   return fileExists(`${projectRoot}/.npmrc`);
 }
 
-async function readNpmConfig ({projectRoot}) {
+async function readNpmConfig({projectRoot}) {
   const pathToConfig = `${projectRoot}/.npmrc`;
 
   if (!(await fileExists(pathToConfig))) return {};
@@ -518,7 +526,7 @@ async function readNpmConfig ({projectRoot}) {
   return parse(await promises.readFile(pathToConfig, 'utf-8'));
 }
 
-async function lifter$4 ({projectRoot}) {
+async function liftNpmConfig({projectRoot}) {
   const {
     provenance,
     'engines-strict': enginesStrict,
@@ -532,14 +540,14 @@ async function lifter$4 ({projectRoot}) {
 
 var npmConfigPlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter$4,
+  lift: liftNpmConfig,
   read: readNpmConfig,
-  scaffold: scaffoldNpmConfig,
-  test: tester$4,
+  scaffold: scaffoldNpmConfiguration,
+  test: npmConfigExists,
   write: writeNpmConfig
 });
 
-async function scaffoldNpm ({projectRoot}) {
+async function scaffoldNpmPackageManager({projectRoot}) {
   const [packageContents, {stdout}] = await Promise.all([
     promises.readFile(`${projectRoot}/package.json`, 'utf-8'),
     execa('npm', ['--version'])
@@ -555,7 +563,7 @@ async function scaffoldNpm ({projectRoot}) {
   });
 }
 
-function determineLockfilePathFor (packageManager) {
+function resolveLockfilePath(packageManager) {
   const lockfilePaths = {
     [packageManagers$1.NPM]: 'package-lock.json',
     [packageManagers$1.YARN]: 'yarn.lock'
@@ -564,14 +572,14 @@ function determineLockfilePathFor (packageManager) {
   return lockfilePaths[packageManager];
 }
 
-function npmIsUsed ({projectRoot, pinnedPackageManager = ''}) {
+function packageManagerIsNpm({projectRoot, pinnedPackageManager = ''}) {
   const [packageManager] = pinnedPackageManager.split('@');
 
   return packageManagers$1.NPM === packageManager
-    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.NPM)}`);
+    || fileExists(`${projectRoot}/${resolveLockfilePath(packageManagers$1.NPM)}`);
 }
 
-async function scaffoldYarn ({projectRoot}) {
+async function scaffoldYarn({projectRoot}) {
   const [packageContents, {stdout}] = await Promise.all([
     promises.readFile(`${projectRoot}/package.json`, 'utf-8'),
     execa('yarn', ['--version'])
@@ -587,51 +595,51 @@ async function scaffoldYarn ({projectRoot}) {
   });
 }
 
-function yarnIsUsed ({projectRoot, pinnedPackageManager = ''}) {
+function packageManagerIsYarn({projectRoot, pinnedPackageManager = ''}) {
   const [packageManager] = pinnedPackageManager.split('@');
 
   return packageManagers$1.YARN === packageManager
-    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.YARN)}`);
+    || fileExists(`${projectRoot}/${resolveLockfilePath(packageManagers$1.YARN)}`);
 }
 
-async function jsPackageManagerIsUsed ({projectRoot}) {
+async function packageManagerInUse({projectRoot}) {
   const [npmFound, yarnFound] = await Promise.all([
-    npmIsUsed({projectRoot}),
-    yarnIsUsed({projectRoot})
+    packageManagerIsNpm({projectRoot}),
+    packageManagerIsYarn({projectRoot})
   ]);
 
   return npmFound || yarnFound;
 }
 
-async function liftCorepack () {
+async function liftCorepack() {
   await execa('corepack', ['use', 'npm@latest']);
 }
 
-async function lifter$3 () {
+async function liftPackageManagers() {
   await liftCorepack();
 
   return {};
 }
 
 const scaffolders = {
-  npm: scaffoldNpm,
+  npm: scaffoldNpmPackageManager,
   yarn: scaffoldYarn
 };
 
-function scaffoldPackageManager ({projectRoot, packageManager}) {
+function scaffoldPackageManager({projectRoot, packageManager}) {
   return scaffolders[packageManager]({projectRoot});
 }
 
-async function resolvePackageManager ({projectRoot, packageManager}) {
+async function resolveCurrentPackageManager({projectRoot, packageManager}) {
   if (packageManager) return packageManager;
 
   const {packageManager: pinnedPackageManager} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf-8'));
 
-  if (await npmIsUsed({projectRoot, pinnedPackageManager})) {
+  if (await packageManagerIsNpm({projectRoot, pinnedPackageManager})) {
     return packageManagers$1.NPM;
   }
 
-  if (await yarnIsUsed({projectRoot, pinnedPackageManager})) {
+  if (await packageManagerIsYarn({projectRoot, pinnedPackageManager})) {
     return packageManagers$1.YARN;
   }
 
@@ -640,14 +648,14 @@ async function resolvePackageManager ({projectRoot, packageManager}) {
 
 var packageManagers = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  defineLockfilePath: determineLockfilePathFor,
-  determineCurrent: resolvePackageManager,
-  lift: lifter$3,
+  defineLockfilePath: resolveLockfilePath,
+  determineCurrent: resolveCurrentPackageManager,
+  lift: liftPackageManagers,
   scaffold: scaffoldPackageManager,
-  test: jsPackageManagerIsUsed
+  test: packageManagerInUse
 });
 
-function buildDocumentationCommand (packageManager) {
+function scaffoldGenerationCommand(packageManager) {
   if (packageManagers$1.NPM === packageManager) return 'npm run generate:md';
   if (packageManagers$1.YARN === packageManager) return 'yarn generate:md';
 
@@ -657,9 +665,9 @@ function buildDocumentationCommand (packageManager) {
   );
 }
 
-function scaffoldDocumentation ({projectTypeResults, packageManager}) {
+function scaffoldDocumentation({projectTypeResults, packageManager}) {
   return {
-    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`,
+    toc: `Run \`${scaffoldGenerationCommand(packageManager)}\` to generate a table of contents`,
     ...projectTypeResults.documentation,
     contributing: `### Dependencies
 
@@ -690,7 +698,7 @@ async function determineLatestVersionOf(nodeVersionCategory) {
   return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
 }
 
-function install$1(nodeVersionCategory) {
+function install(nodeVersionCategory) {
   info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
 
   const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
@@ -698,7 +706,7 @@ function install$1(nodeVersionCategory) {
   return subprocess;
 }
 
-async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
+async function scaffoldNodeVersion({projectRoot, nodeVersionCategory}) {
   if (!nodeVersionCategory) return undefined;
 
   const lowerCaseCategory = nodeVersionCategory.toLowerCase();
@@ -708,23 +716,23 @@ async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
 
   await promises.writeFile(`${projectRoot}/.nvmrc`, version);
 
-  await install$1(nodeVersionCategory);
+  await install(nodeVersionCategory);
 
   return version;
 }
 
-function nvmIsUsed ({projectRoot}) {
+function nodeVersionMangerInUse({projectRoot}) {
   return fileExists(`${projectRoot}/.nvmrc`);
 }
 
-function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
+function buildIgnoreLists(vcsIgnoreLists = {}) {
   return {
     files: vcsIgnoreLists.files || [],
     directories: ['/node_modules/', ...vcsIgnoreLists.directories || []]
   };
 }
 
-function buildPackageName (projectName, scope) {
+function determinePackageName(projectName, scope) {
   const name = `${scope ? `@${scope}/` : ''}${projectName}`;
 
   const {validForNewPackages, errors} = validatePackageName(name);
@@ -735,7 +743,7 @@ function buildPackageName (projectName, scope) {
   throw new Error(`The package name ${name} is invalid:${EOL}\t* ${errors.join(`${EOL}\t* `)}`);
 }
 
-function buildPackageDetails ({
+function scaffoldPackageJsonDetails({
   packageName,
   dialect,
   license,
@@ -752,7 +760,7 @@ function buildPackageDetails ({
   };
 }
 
-async function scaffoldPackage ({
+async function scaffoldPackage({
   projectRoot,
   projectName,
   scope,
@@ -763,11 +771,11 @@ async function scaffoldPackage ({
 }) {
   info('Configuring package.json');
 
-  const packageName = buildPackageName(projectName, scope);
+  const packageName = determinePackageName(projectName, scope);
 
   await writePackageJson({
     projectRoot,
-    config: await buildPackageDetails({
+    config: await scaffoldPackageJsonDetails({
       packageName,
       dialect,
       license,
@@ -816,7 +824,7 @@ function sortProperties(packageContents) {
   );
 }
 
-function defineVcsHostDetails (vcs, pathWithinParent) {
+function scaffoldVcsHostDetails(vcs, pathWithinParent) {
   return vcs && 'github' === vcs.host && {
     repository: pathWithinParent
       ? {
@@ -860,7 +868,12 @@ function getExactFlag(manager) {
   return details[manager].installationFlags.exact;
 }
 
-async function install (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
+async function installDependencies(
+  dependencies,
+  dependenciesType,
+  projectRoot,
+  packageManager = packageManagers$1.NPM
+) {
   if (dependencies.length) {
     info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
 
@@ -875,7 +888,7 @@ async function install (dependencies, dependenciesType, projectRoot, packageMana
   } else warn(`No ${dependenciesType} dependencies to install`);
 }
 
-async function remove ({packageManager, dependencies}) {
+async function removeDependencies({packageManager, dependencies}) {
   if (dependencies.length) {
     info('Removing dependencies dependencies', {level: 'secondary'});
 
@@ -883,7 +896,7 @@ async function remove ({packageManager, dependencies}) {
   }
 }
 
-async function processDependencies ({dependencies = {}, devDependencies, projectRoot, packageManager}) {
+async function processDependencies({dependencies = {}, devDependencies, projectRoot, packageManager}) {
   info('Processing dependencies');
 
   if (Array.isArray(devDependencies)) {
@@ -899,9 +912,9 @@ async function processDependencies ({dependencies = {}, devDependencies, project
   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});
+    await installDependencies(production, PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await installDependencies(development, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await removeDependencies({packageManager, dependencies: dependenciesToRemove});
   } catch (e) {
     error('Failed to update dependencies');
     error(e, {level: 'secondary'});
@@ -936,13 +949,14 @@ function isPostScriptFor(a, b) {
   return isRelatedScript(a, b, 'post');
 }
 
-function getBaseScriptOf(script) {
+function stripPrefix(script) {
   if (script.startsWith('pre')) return script.slice(3);
   if (script.startsWith('post')) return script.slice(4);
   return script;
 }
 
-function getCategoryOrder(base) {
+function getCategoryOrder(script) {
+  const base = stripPrefix(script);
   if ('test' === base) return 0;
   if (base.startsWith('lint:')) return 1;
   if (base.startsWith('test:unit')) return 2;
@@ -958,14 +972,14 @@ function compareScriptNames(a, b) {
   if (isPostScriptFor(a, b)) return 1;
   if (isPostScriptFor(b, a)) return -1;
 
-  const aBase = getBaseScriptOf(a);
-  const bBase = getBaseScriptOf(b);
-
-  const categoryDiff = getCategoryOrder(aBase) - getCategoryOrder(bBase);
+  const categoryDiff = getCategoryOrder(a) - getCategoryOrder(b);
   if (0 !== categoryDiff) return 0 > categoryDiff ? -1 : 1;
 
-  const aKey = bBase === aBase || b === aBase || aBase.startsWith(`${b}:`) ? aBase : a;
-  const bKey = aBase === bBase || a === bBase || bBase.startsWith(`${a}:`) ? bBase : b;
+  const aStripped = stripPrefix(a);
+  const bStripped = stripPrefix(b);
+
+  const aKey = aStripped !== a ? aStripped : a;
+  const bKey = bStripped !== b ? bStripped : b;
 
   return aKey.localeCompare(bKey);
 }
@@ -986,7 +1000,7 @@ function liftScripts({existingScripts, scripts}) {
   };
 }
 
-async function liftPackage$1 ({
+async function liftPackageJson({
   projectRoot,
   scripts,
   tags,
@@ -1008,7 +1022,7 @@ async function liftPackage$1 ({
     projectRoot,
     config: sortProperties({
       ...existingPackageJsonContents,
-      ...defineVcsHostDetails(vcs, pathWithinParent),
+      ...scaffoldVcsHostDetails(vcs, pathWithinParent),
       scripts: liftedScripts,
       ...tags && {
         keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
@@ -1024,11 +1038,11 @@ async function liftPackage$1 ({
   });
 }
 
-function determinePackageAccessLevelFromProjectVisibility ({projectVisibility}) {
+function mapProjectVisibility({projectVisibility}) {
   return 'Public' === projectVisibility ? 'public' : 'restricted';
 }
 
-function defineBadges (packageName, accessLevel) {
+function scaffoldPublishableBadges(packageName, accessLevel) {
   return {
     consumer: {
       ...'public' === accessLevel && {
@@ -1043,7 +1057,7 @@ function defineBadges (packageName, accessLevel) {
   };
 }
 
-function enhanceSlsa ({provenance}) {
+function scaffoldSlsa({provenance}) {
   {
     return {
       badges: {
@@ -1059,13 +1073,13 @@ function enhanceSlsa ({provenance}) {
   }
 }
 
-async function liftProvenance ({projectRoot, packageDetails}) {
+async function liftProvenance({projectRoot, packageDetails}) {
   const {publishConfig: {access} = {}} = packageDetails;
 
   if ('public' === access) {
     await mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
 
-    return enhanceSlsa({provenance: true});
+    return scaffoldSlsa({provenance: true});
   }
 
   return {};
@@ -1083,14 +1097,14 @@ async function liftPublishable({projectRoot, packageDetails}) {
       homepage,
       dependencies: {javascript: {development: ['publint']}},
       scripts: {'lint:publish': 'publint --strict'},
-      badges: defineBadges(packageName, packageAccessLevel)
+      badges: scaffoldPublishableBadges(packageName, packageAccessLevel)
     }
   );
 }
 
-async function scaffoldPublishable ({packageName, packageAccessLevel}) {
+async function scaffoldPublishable({packageName, packageAccessLevel}) {
   return {
-    badges: await defineBadges(packageName, packageAccessLevel)
+    badges: await scaffoldPublishableBadges(packageName, packageAccessLevel)
   };
 }
 
@@ -1104,7 +1118,7 @@ function getInstallationCommand(packageManager) {
   );
 }
 
-function scaffoldPackageDocumentation ({scope, packageName, packageManager, visibility, provideExample}) {
+function scaffoldPackageDocumentation({scope, packageName, packageManager, visibility, provideExample}) {
   return {
     usage: `### Installation
 ${'Private' === visibility ? `
@@ -1119,13 +1133,13 @@ $ ${getInstallationCommand(packageManager)} ${packageName}
 
 ### Example
 
-run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example`
+run \`${scaffoldGenerationCommand(packageManager)}\` to inject the usage example`
     : ''
 }`
   };
 }
 
-async function chooseBundler ({bundlers, decisions}) {
+async function gatherBundlerInput({bundlers, decisions}) {
   if (!Object.keys(bundlers).length) return 'Other';
 
   const answers = await prompt$1([{
@@ -1138,8 +1152,8 @@ async function chooseBundler ({bundlers, decisions}) {
   return answers[questionNames$1.PACKAGE_BUNDLER];
 }
 
-async function scaffoldBundler ({projectRoot, projectType, bundlers, dialect, decisions}) {
-  const chosenBundler = await chooseBundler({bundlers, decisions});
+async function scaffoldBundler({projectRoot, projectType, bundlers, dialect, decisions}) {
+  const chosenBundler = await gatherBundlerInput({bundlers, decisions});
 
   return scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
 }
@@ -1210,7 +1224,7 @@ async function scaffoldPackageProjectType({
 }) {
   info('Scaffolding Package Details');
 
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
+  const packageAccessLevel = mapProjectVisibility({projectVisibility: visibility});
   const [detailsForBuild, publishableResults] = await Promise.all([
     buildDetails({
       projectRoot,
@@ -1275,13 +1289,15 @@ function liftPackage({projectRoot, packageDetails}) {
   return liftPublishable({projectRoot, packageDetails});
 }
 
-async function isPackage ({packageDetails: {exports: exports$1, publishConfig, bin, private: projectMarkedPrivate}}) {
+async function projectIsPackage({
+  packageDetails: {exports: exports$1, publishConfig, bin, private: projectMarkedPrivate}
+}) {
   return !projectMarkedPrivate && (!!exports$1 || (!!publishConfig && !bin));
 }
 
 const defaultBuildDirectory$1 = 'public';
 
-async function scaffoldApplicationType ({projectRoot}) {
+async function scaffoldApplication({projectRoot}) {
   info('Scaffolding Application Details');
 
   await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
@@ -1301,11 +1317,11 @@ async function scaffoldApplicationType ({projectRoot}) {
   };
 }
 
-function isApplication ({packageDetails}) {
+function projectIsApplication({packageDetails}) {
   return !!packageDetails.private;
 }
 
-async function scaffoldMonorepoType ({projectRoot}) {
+async function scaffoldMonorepo({projectRoot}) {
   info('Scaffolding Monorepo Details');
 
   await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
@@ -1330,7 +1346,7 @@ async function scaffoldCli({
   decisions,
   packageBundlers
 }) {
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
+  const packageAccessLevel = mapProjectVisibility({projectVisibility: visibility});
   const [bundlerResults, publishableResults] = await Promise.all([
     scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.CLI}),
     scaffoldPublishable({packageName, packageAccessLevel}),
@@ -1365,7 +1381,7 @@ async function scaffoldCli({
   ]);
 }
 
-async function isCli ({packageDetails: {bin}}) {
+async function projectIsCli({packageDetails: {bin}}) {
   return !!bin;
 }
 
@@ -1373,7 +1389,7 @@ function liftCli({projectRoot, packageDetails}) {
   return liftPublishable({projectRoot, packageDetails});
 }
 
-async function scaffoldProjectType ({
+async function scaffoldProjectType({
   projectType,
   projectRoot,
   projectName,
@@ -1403,7 +1419,7 @@ async function scaffoldProjectType ({
         publishRegistry
       });
     case projectTypes$1.APPLICATION:
-      return scaffoldApplicationType({projectRoot});
+      return scaffoldApplication({projectRoot});
     case projectTypes$1.CLI:
       return scaffoldCli({
         packageName,
@@ -1415,7 +1431,7 @@ async function scaffoldProjectType ({
         packageBundlers
       });
     case projectTypes$1.MONOREPO:
-      return scaffoldMonorepoType({projectRoot});
+      return scaffoldMonorepo({projectRoot});
     case 'Other':
       return {};
     default:
@@ -1423,19 +1439,19 @@ async function scaffoldProjectType ({
   }
 }
 
-async function tester$3 ({projectRoot, packageDetails}) {
-  return await isPackage({packageDetails})
-    || await isCli({packageDetails})
-    || isApplication({packageDetails});
+async function isProjectType({projectRoot, packageDetails}) {
+  return await projectIsPackage({packageDetails})
+    || await projectIsCli({packageDetails})
+    || projectIsApplication({packageDetails});
 }
 
 function vcsRepositoryHostedOnGithub(vcs) {
   return vcs && 'github' === vcs.host;
 }
 
-async function lifter$2 ({projectRoot, packageDetails, vcs}) {
-  if (await isPackage({packageDetails})) return liftPackage({projectRoot, packageDetails});
-  if (await isCli({packageDetails})) return liftCli({projectRoot, packageDetails});
+async function liftProjectType({projectRoot, packageDetails, vcs}) {
+  if (await projectIsPackage({packageDetails})) return liftPackage({projectRoot, packageDetails});
+  if (await projectIsCli({packageDetails})) return liftCli({projectRoot, packageDetails});
 
   let homepage;
 
@@ -1450,12 +1466,12 @@ async function lifter$2 ({projectRoot, packageDetails, vcs}) {
 
 var projectTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter$2,
+  lift: liftProjectType,
   scaffold: scaffoldProjectType,
-  test: tester$3
+  test: isProjectType
 });
 
-async function chooseProjectTypePlugin ({types, projectType, decisions}) {
+async function gatherProjectTypePluginInput({types, projectType, decisions}) {
   if (!Object.keys(types).length) return 'Other';
 
   const answers = await prompt$1([{
@@ -1468,7 +1484,7 @@ async function chooseProjectTypePlugin ({types, projectType, decisions}) {
   return answers[questionNames$1.PROJECT_TYPE_CHOICE];
 }
 
-async function scaffoldProjectTypePlugin ({
+async function scaffoldProjectTypePlugin({
   projectRoot,
   projectType,
   projectName,
@@ -1484,7 +1500,7 @@ async function scaffoldProjectTypePlugin ({
 
   if (!pluginsForProjectType) return {};
 
-  const chosenType = await chooseProjectTypePlugin({types: pluginsForProjectType, decisions, projectType});
+  const chosenType = await gatherProjectTypePluginInput({types: pluginsForProjectType, decisions, projectType});
 
   return scaffoldChoice(
     pluginsForProjectType,
@@ -1493,7 +1509,7 @@ async function scaffoldProjectTypePlugin ({
   );
 }
 
-async function scaffoldTesting ({
+async function scaffoldTesting({
   projectRoot,
   visibility,
   tests: {unit, integration},
@@ -1521,7 +1537,7 @@ async function scaffoldTesting ({
   );
 }
 
-function buildAllowedHostsList ({packageManager, registries = {}}) {
+function buildAllowedHosts({packageManager, registries = {}}) {
   return [
     ...!registries.registry ? [packageManager] : [],
     ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
@@ -1534,7 +1550,7 @@ function lockfileLintSupports(packageManager) {
   return lockfileLintSupportedPackageManagers.includes(packageManager);
 }
 
-async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
+async function scaffoldLockfileLint({projectRoot, packageManager, registries}) {
   if (!lockfileLintSupports(packageManager)) {
     throw new Error(
       `The ${packageManager} package manager is currently not supported by lockfile-lint. `
@@ -1542,15 +1558,15 @@ async function scaffoldLockfileLint ({projectRoot, packageManager, registries})
     );
   }
 
-  await write$2({
+  await write$1({
     name: 'lockfile-lint',
     format: fileTypes.JSON,
     path: projectRoot,
     config: {
-      path: determineLockfilePathFor(packageManager),
+      path: resolveLockfilePath(packageManager),
       type: packageManager,
       'validate-https': true,
-      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+      'allowed-hosts': buildAllowedHosts({packageManager, registries})
     }
   });
 
@@ -1560,7 +1576,7 @@ async function scaffoldLockfileLint ({projectRoot, packageManager, registries})
   };
 }
 
-function lockfileLintIsAlreadyConfigured ({projectRoot}) {
+function lockfileLintInUse({projectRoot}) {
   return fileExists(`${projectRoot}/.lockfile-lintrc.json`);
 }
 
@@ -1571,10 +1587,10 @@ function read({projectRoot}) {
 }
 
 function write({projectRoot, config}) {
-  return write$2({name: configName, format: fileTypes.JSON, path: projectRoot, config});
+  return write$1({name: configName, format: fileTypes.JSON, path: projectRoot, config});
 }
 
-async function scaffoldLinting ({projectRoot, packageManager, registries}) {
+async function scaffoldLinting({projectRoot, packageManager, registries}) {
   return scaffoldLockfileLint({projectRoot, packageManager, registries});
 }
 
@@ -1608,8 +1624,8 @@ async function scaffoldVerification({
   return deepmerge.all([testingResults, lintingResults, huskyResults]);
 }
 
-async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
-  await write$2({
+async function scaffoldRemark({config, projectRoot, projectType, vcs}) {
+  await write$1({
     format: fileTypes.JSON,
     path: projectRoot,
     name: 'remark',
@@ -1642,7 +1658,7 @@ async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
   );
 }
 
-async function scaffoldCodeStyle ({
+async function scaffoldCodeStyle({
   projectRoot,
   projectType,
   configs,
@@ -1663,22 +1679,22 @@ async function scaffoldCodeStyle ({
   ].filter(Boolean)));
 }
 
-function lifter$1 (options) {
+function liftCodeStyle(options) {
   return applyEnhancers({options, enhancers: [eslintPlugin]});
 }
 
-function tester$2 (options) {
+function codeStyleConfigured(options) {
   return test$1(options);
 }
 
 var codeStylePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter$1,
+  lift: liftCodeStyle,
   scaffold: scaffoldCodeStyle,
-  test: tester$2
+  test: codeStyleConfigured
 });
 
-async function scaffolder (options) {
+async function scaffoldJavascript(options) {
   info('Initializing JavaScript project');
 
   const {
@@ -1755,7 +1771,7 @@ async function scaffolder (options) {
   });
   const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([
     scaffoldNodeVersion({projectRoot, nodeVersionCategory}),
-    scaffoldNpmConfig({projectType, projectRoot}),
+    scaffoldNpmConfiguration({projectType, projectRoot}),
     scaffoldDialect({
       dialect,
       configs,
@@ -1804,16 +1820,16 @@ async function scaffolder (options) {
     ...mergedContributions,
     documentation: scaffoldDocumentation({projectTypeResults, packageManager}),
     tags: projectTypeResults.tags,
-    vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
-    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`
+    vcsIgnore: buildIgnoreLists(mergedContributions.vcsIgnore),
+    verificationCommand: `${scaffoldGenerationCommand(packageManager)} && ${packageManager} test`
   };
 }
 
-function tester$1 () {
+function registriesAreInUse() {
   return true;
 }
 
-function buildRegistriesConfig (registries = {}) {
+function buildRegistriesList(registries = {}) {
   return Object.entries(registries)
     .filter(([scope]) => 'publish' !== scope)
     .reduce((acc, [scope, url]) => {
@@ -1824,7 +1840,7 @@ function buildRegistriesConfig (registries = {}) {
 }
 
 async function updateRegistriesInNpmConfig(registries, projectRoot) {
-  const registriesForNpmConfig = buildRegistriesConfig(registries);
+  const registriesForNpmConfig = buildRegistriesList(registries);
 
   await writeNpmConfig({
     projectRoot,
@@ -1840,15 +1856,15 @@ async function updateRegistriesInLockfileLintConfig(projectRoot, packageManager,
     projectRoot,
     config: {
       ...await read({projectRoot}),
-      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+      'allowed-hosts': buildAllowedHosts({packageManager, registries})
     }
   });
 }
 
-async function lifter ({projectRoot, packageManager, configs: {registries}}) {
+async function liftRegistries({projectRoot, packageManager, configs: {registries}}) {
   await updateRegistriesInNpmConfig(registries, projectRoot);
 
-  if (!(await lockfileLintIsAlreadyConfigured({projectRoot}))) {
+  if (!(await lockfileLintInUse({projectRoot}))) {
     return scaffoldLockfileLint({projectRoot, packageManager, registries});
   }
 
@@ -1859,8 +1875,8 @@ async function lifter ({projectRoot, packageManager, configs: {registries}}) {
 
 var registriesPlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter,
-  test: tester$1
+  lift: liftRegistries,
+  test: registriesAreInUse
 });
 
 async function test({projectRoot}) {
@@ -1869,7 +1885,7 @@ async function test({projectRoot}) {
   return !!engines?.node;
 }
 
-async function lift$1({packageDetails: {name}}) {
+async function lift({packageDetails: {name}}) {
   return {
     dependencies: {javascript: {development: ['ls-engines']}},
     scripts: {'lint:engines': 'ls-engines'},
@@ -1879,15 +1895,22 @@ async function lift$1({packageDetails: {name}}) {
 
 var enginesEnhancer = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lift$1,
+  lift: lift,
   test: test
 });
 
-async function lift ({projectRoot, vcs, results, pathWithinParent, enhancers = {}, configs = {}}) {
+async function liftJavaScript({
+  projectRoot,
+  vcs,
+  results,
+  pathWithinParent,
+  enhancers = {},
+  configs = {}
+}) {
   info('Lifting JavaScript-specific details');
 
   const [packageManager, packageContents] = await Promise.all([
-    resolvePackageManager({projectRoot, packageManager: results.packageManager}),
+    resolveCurrentPackageManager({projectRoot, packageManager: results.packageManager}),
     promises.readFile(`${projectRoot}/package.json`, 'utf8')
   ]);
 
@@ -1909,15 +1932,15 @@ async function lift ({projectRoot, vcs, results, pathWithinParent, enhancers = {
     options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents), configs}
   });
 
-  await liftPackage$1(deepmerge.all([{projectRoot, packageManager, vcs, pathWithinParent}, enhancerResults]));
+  await liftPackageJson(deepmerge.all([{projectRoot, packageManager, vcs, pathWithinParent}, enhancerResults]));
 
   return enhancerResults;
 }
 
-async function tester ({projectRoot}) {
+async function projectUsesJavaScript({projectRoot}) {
   const [nvmFound, jsPackageManagerFound] = await Promise.all([
-    nvmIsUsed({projectRoot}),
-    jsPackageManagerIsUsed({projectRoot})
+    nodeVersionMangerInUse({projectRoot}),
+    packageManagerInUse({projectRoot})
   ]);
 
   const jsProjectFound = nvmFound || jsPackageManagerFound;
@@ -1929,5 +1952,5 @@ async function tester ({projectRoot}) {
 
 const questionNames = {...questionNames$2, ...questionNames$1};
 
-export { lift, questionNames, scaffolder as scaffold, scaffoldUnitTesting, tester as test };
+export { liftJavaScript as lift, questionNames, scaffoldJavascript as scaffold, scaffoldUnitTesting, projectUsesJavaScript as test };
 //# sourceMappingURL=index.js.map