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

package/lib/index.mjs

@@ -1,1824 +0,0 @@
-import { questionNames as questionNames$2, questions } from '@travi/language-scaffolder-prompts';
-import deepmerge from 'deepmerge';
-import { fileTypes, fileExists, validateOptions, applyEnhancers, writeConfigFile } from '@form8ion/core';
-import { scaffoldChoice, projectTypes as projectTypes$1, packageManagers as packageManagers$1, mergeIntoExistingPackageJson, dialects as dialects$1, writePackageJson, DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE } from '@form8ion/javascript-core';
-import joi from 'joi';
-import { prompt as prompt$1, Separator } from '@form8ion/overridable-prompts';
-import { scaffold, lift as lift$3 } from '@form8ion/codecov';
-import { write as write$2 } 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',
-  NODE_VERSION_CATEGORY: 'nodeVersionCategory',
-  PACKAGE_MANAGER: 'packageManager',
-  PACKAGE_BUNDLER: 'packageBundler',
-  PROJECT_TYPE: 'projectType',
-  PROJECT_TYPE_CHOICE: 'projectTypeChoice',
-  SHOULD_BE_SCOPED: 'shouldBeScoped',
-  SCOPE: 'scope',
-  AUTHOR_NAME: 'authorName',
-  AUTHOR_EMAIL: 'authorEmail',
-  AUTHOR_URL: 'authorUrl',
-  HOST: 'host',
-  CONFIGURE_LINTING: 'configureLint',
-  PROVIDE_EXAMPLE: 'provideExample',
-  DIALECT: 'dialect'
-};
-
-async function scaffoldC8 ({projectRoot}) {
-  await write$2({
-    name: 'c8',
-    format: fileTypes.JSON,
-    path: projectRoot,
-    config: {
-      reporter: ['lcov', 'text-summary', 'html'],
-      exclude: ['src/**/*-test.js', 'test/', 'thirdparty-wrappers/', 'vendor/']
-    }
-  });
-
-  return {
-    devDependencies: ['cross-env', 'c8'],
-    vcsIgnore: {files: [], directories: ['/coverage/']},
-    eslint: {ignore: {directories: ['/coverage/']}}
-  };
-}
-
-async function scaffoldCoverage ({projectRoot, vcs, visibility, pathWithinParent}) {
-  return deepmerge(await scaffoldC8({projectRoot}), await scaffold({vcs, visibility, pathWithinParent}));
-}
-
-function nycIsConfigured ({projectRoot}) {
-  return fileExists(`${projectRoot}/.nycrc`);
-}
-
-async function removeDependencies ({packageManager, dependencies}) {
-  await execa(packageManager, ['remove', ...dependencies]);
-}
-
-async function removeNyc ({projectRoot, packageManager}) {
-  await Promise.all([
-    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 lift$3({projectRoot, packageManager, vcs});
-
-  if (await nycIsConfigured({projectRoot})) {
-    const [c8Results] = await Promise.all([
-      scaffoldC8({projectRoot}),
-      removeNyc({projectRoot, packageManager})
-    ]);
-
-    return deepmerge.all([
-      c8Results,
-      codecovResults,
-      {
-        scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'},
-        nextSteps: [{
-          summary: 'Remove use of `@istanbuljs/nyc-config-babel` from your babel config, if present,'
-            + ' after the migration away from `nyc`'
-        }]
-      }
-    ]);
-  }
-
-  return codecovResults;
-}
-
-function c8IsConfigured ({projectRoot}) {
-  return fileExists(`${projectRoot}/.c8rc.json`);
-}
-
-async function tester$4 ({projectRoot}) {
-  const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({projectRoot}), nycIsConfigured({projectRoot})]);
-
-  return c8Exists || nycExists;
-}
-
-var coveragePlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldCoverage,
-  lift: lift$2,
-  test: tester$4
-});
-
-const unitTestFrameworksSchema = joi.object().required().pattern(/^/, joi.object({
-  scaffolder: joi.func().arity(1).required()
-}));
-
-async function chooseFramework ({frameworks, decisions}) {
-  if (!Object.keys(frameworks).length) return 'Other';
-
-  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 Separator(), 'Other']
-  }], decisions);
-
-  return answers[questionNames$1.UNIT_TEST_FRAMEWORK];
-}
-
-async function scaffoldUnitTesting ({projectRoot, frameworks, decisions, visibility, vcs, pathWithinParent, dialect}) {
-  const validatedFrameworks = validateOptions(unitTestFrameworksSchema, frameworks);
-  const [framework, coverage] = await Promise.all([
-    chooseFramework({frameworks: validatedFrameworks, decisions})
-      .then(chosenFramework => scaffoldChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
-    scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent})
-  ]);
-
-  return deepmerge.all([
-    {scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'}},
-    framework,
-    coverage
-  ]);
-}
-
-async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
-  await write$2({
-    format: fileTypes.JSON,
-    path: projectRoot,
-    name: 'remark',
-    config: {
-      settings: {
-        listItemIndent: 'one',
-        emphasis: '_',
-        strong: '_',
-        bullet: '*',
-        incrementListMarker: false
-      },
-      plugins: [
-        config,
-        ['remark-toc', {tight: true}],
-        ...projectTypes$1.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
-        ...!vcs ? [['validate-links', {repository: false}]] : []
-      ]
-    }
-  });
-
-  return deepmerge(
-    {
-      devDependencies: [config, 'remark-cli', 'remark-toc'],
-      scripts: {
-        'lint:md': 'remark . --frail',
-        'generate:md': 'remark . --output'
-      }
-    },
-    {...projectTypes$1.PACKAGE === projectType && {devDependencies: ['remark-usage']}}
-  );
-}
-
-async function scaffoldCodeStyle ({
-  projectRoot,
-  projectType,
-  configs,
-  vcs,
-  configureLinting
-}) {
-  return deepmerge.all(await Promise.all([
-    configs.eslint
-      && configureLinting
-      && scaffold$1({projectRoot, config: configs.eslint}),
-    scaffoldRemark({
-      projectRoot,
-      projectType,
-      vcs,
-      config: configs.remark || '@form8ion/remark-lint-preset'
-    }),
-    scaffold$2({projectRoot, config: configs.prettier})
-  ].filter(Boolean)));
-}
-
-function lifter$4 (options) {
-  return applyEnhancers({options, enhancers: [eslintPlugin]});
-}
-
-function tester$3 (options) {
-  return test$1(options);
-}
-
-var codeStylePlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldCodeStyle,
-  lift: lifter$4,
-  test: tester$3
-});
-
-async function write$1 ({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,
-  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 fileExists(`${projectRoot}/.npmrc`);
-}
-
-async function lifter$3 ({projectRoot}) {
-  const pathToConfig = `${projectRoot}/.npmrc`;
-
-  const {
-    provenance,
-    'engines-strict': enginesStrict,
-    ...remainingProperties
-  } = parse(await promises$1.readFile(pathToConfig, 'utf-8'));
-
-  await promises$1.writeFile(pathToConfig, stringify(remainingProperties));
-
-  return {};
-}
-
-var npmConfigPlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldNpmConfig,
-  test: tester$2,
-  lift: lifter$3
-});
-
-async function test({projectRoot}) {
-  const {engines} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
-
-  return !!engines?.node;
-}
-
-async function lift$1({packageDetails: {name}}) {
-  return {
-    devDependencies: ['ls-engines'],
-    scripts: {'lint:engines': 'ls-engines'},
-    badges: {consumer: {node: {img: `https://img.shields.io/node/v/${name}?logo=node.js`, text: 'node'}}}
-  };
-}
-
-var enginesEnhancer = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  test: test,
-  lift: lift$1
-});
-
-function buildDocumentationCommand (packageManager) {
-  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(packageManagers$1).join(' and ')} are currently supported.`
-  );
-}
-
-function getInstallationCommand(packageManager) {
-  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(packageManagers$1).join(' and ')} are currently supported.`
-  );
-}
-
-function scaffoldPackageDocumentation ({scope, packageName, packageManager, visibility, provideExample}) {
-  return {
-    usage: `### Installation
-${'Private' === visibility ? `
-:warning: this is a private package, so you will need to use an npm token with
-access to private packages under \`@${scope}\`
-` : ''
-}
-\`\`\`sh
-$ ${getInstallationCommand(packageManager)} ${packageName}
-\`\`\`${provideExample
-    ? `
-
-### Example
-
-run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example`
-    : ''
-}`
-  };
-}
-
-function determinePackageAccessLevelFromProjectVisibility ({projectVisibility}) {
-  return 'Public' === projectVisibility ? 'public' : 'restricted';
-}
-
-function defineBadges (packageName, accessLevel) {
-  return {
-    consumer: {
-      ...'public' === accessLevel && {
-        npm: {
-          img: `https://img.shields.io/npm/v/${packageName}?logo=npm`,
-          text: 'npm',
-          link: `https://www.npmjs.com/package/${packageName}`
-        }
-      }
-    },
-    status: {}
-  };
-}
-
-function enhanceSlsa ({provenance}) {
-  if (provenance) {
-    return {
-      badges: {
-        status: {
-          slsa: {
-            img: 'https://slsa.dev/images/gh-badge-level2.svg',
-            url: 'https://slsa.dev',
-            text: 'SLSA Level 2'
-          }
-        }
-      }
-    };
-  }
-
-  return {};
-}
-
-async function liftProvenance ({projectRoot, packageDetails}) {
-  const {publishConfig: {access}} = packageDetails;
-
-  if ('public' === access) {
-    await mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
-
-    return enhanceSlsa({provenance: true});
-  }
-
-  return {};
-}
-
-async function liftPublishable ({projectRoot, packageDetails}) {
-  const {name: packageName, publishConfig: {access: packageAccessLevel}} = packageDetails;
-  const homepage = `https://npm.im/${packageName}`;
-
-  await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
-
-  return deepmerge(
-    await liftProvenance({packageDetails, projectRoot}),
-    {
-      homepage,
-      devDependencies: ['publint'],
-      scripts: {'lint:publish': 'publint --strict'},
-      badges: defineBadges(packageName, packageAccessLevel)
-    }
-  );
-}
-
-async function scaffoldPublishable ({packageName, packageAccessLevel}) {
-  return {
-    badges: await defineBadges(packageName, packageAccessLevel)
-  };
-}
-
-async function chooseBundler ({bundlers, decisions}) {
-  if (!Object.keys(bundlers).length) return 'Other';
-
-  const answers = await prompt$1([{
-    name: questionNames$1.PACKAGE_BUNDLER,
-    type: 'list',
-    message: 'Which bundler should be used?',
-    choices: [...Object.keys(bundlers), 'Other']
-  }], decisions);
-
-  return answers[questionNames$1.PACKAGE_BUNDLER];
-}
-
-async function scaffoldBundler ({projectRoot, projectType, bundlers, dialect, decisions}) {
-  const chosenBundler = await chooseBundler({bundlers, decisions});
-
-  return scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
-}
-
-function determinePathToTemplateFile (fileName) {
-  const [, __dirname] = filedirname();
-
-  return resolve(__dirname, '..', 'templates', fileName);
-}
-
-const defaultBuildDirectory$2 = 'lib';
-
-async function createExample(projectRoot, projectName, dialect) {
-  return promises.writeFile(
-    `${projectRoot}/example.js`,
-    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(`${projectRoot}/index.js`),
-    provideExample
-      ? promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)
-      : Promise.resolve()
-  ]);
-
-  return {};
-}
-
-async function buildDetails ({
-  projectRoot,
-  projectName,
-  visibility,
-  packageName,
-  packageBundlers,
-  dialect,
-  provideExample,
-  decisions
-}) {
-  if (dialects$1.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName, provideExample});
-
-  const pathToCreatedSrcDirectory = await mkdir(`${projectRoot}/src`);
-  const [bundlerResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.PACKAGE}),
-    provideExample ? await createExample(projectRoot, projectName, dialect) : Promise.resolve,
-    touch(`${pathToCreatedSrcDirectory}/index.js`)
-  ]);
-
-  return deepmerge(
-    bundlerResults,
-    {
-      devDependencies: ['rimraf'],
-      scripts: {
-        clean: `rimraf ./${defaultBuildDirectory$2}`,
-        prebuild: 'run-s clean',
-        build: 'npm-run-all --print-label --parallel build:*',
-        prepack: 'run-s build',
-        ...provideExample && {'pregenerate:md': 'run-s build'}
-      },
-      vcsIgnore: {directories: [`/${defaultBuildDirectory$2}/`]},
-      buildDirectory: defaultBuildDirectory$2,
-      badges: {
-        consumer: {
-          ...'Public' === visibility && {
-            runkit: {
-              img: `https://badge.runkitcdn.com/${packageName}.svg`,
-              text: `Try ${packageName} on RunKit`,
-              link: `https://npm.runkit.com/${packageName}`
-            }
-          }
-        }
-      }
-    }
-  );
-}
-
-async function scaffoldPackageType ({
-  projectRoot,
-  projectName,
-  packageName,
-  packageManager,
-  visibility,
-  scope,
-  packageBundlers,
-  decisions,
-  dialect,
-  provideExample,
-  publishRegistry
-}) {
-  info('Scaffolding Package Details');
-
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
-  const [detailsForBuild, publishableResults] = await Promise.all([
-    buildDetails({
-      projectRoot,
-      projectName,
-      packageBundlers,
-      visibility,
-      packageName,
-      dialect,
-      provideExample,
-      decisions
-    }),
-    scaffoldPublishable({packageName, packageAccessLevel}),
-    mergeIntoExistingPackageJson({
-      projectRoot,
-      config: {
-        files: ['example.js', ...dialects$1.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
-        publishConfig: {
-          access: packageAccessLevel,
-          ...publishRegistry && {registry: publishRegistry}
-        },
-        sideEffects: false,
-        ...'Public' === visibility && {runkitExampleFilename: './example.js'},
-        ...dialects$1.BABEL === dialect && {
-          main: './lib/index.js',
-          module: './lib/index.mjs',
-          exports: {
-            module: './lib/index.mjs',
-            require: './lib/index.js',
-            import: './lib/index.mjs'
-          }
-        },
-        ...dialects$1.ESM === dialect && {
-          main: './lib/index.js',
-          exports: './lib/index.js'
-        },
-        ...dialects$1.TYPESCRIPT === dialect && {
-          main: './lib/index.js',
-          module: './lib/index.mjs',
-          types: './lib/index.d.ts',
-          exports: {
-            types: './lib/index.d.ts',
-            require: './lib/index.js',
-            import: './lib/index.mjs'
-          }
-        }
-      }
-    })
-  ]);
-
-  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: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'}
-      ]
-    },
-    detailsForBuild
-  ]);
-}
-
-function liftPackage$1 ({projectRoot, packageDetails}) {
-  return liftPublishable({projectRoot, packageDetails});
-}
-
-async function isPackage ({packageDetails: {exports, publishConfig, bin}}) {
-  return !!exports || (!!publishConfig && !bin);
-}
-
-const defaultBuildDirectory$1 = 'public';
-
-async function scaffoldApplicationType ({projectRoot}) {
-  info('Scaffolding Application Details');
-
-  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
-
-  const buildDirectory = defaultBuildDirectory$1;
-
-  return {
-    scripts: {
-      clean: `rimraf ./${buildDirectory}`,
-      start: `node ./${buildDirectory}/index.js`,
-      prebuild: 'run-s clean'
-    },
-    dependencies: [],
-    devDependencies: ['rimraf'],
-    vcsIgnore: {files: ['.env'], directories: [`/${buildDirectory}/`]},
-    buildDirectory,
-    nextSteps: []
-  };
-}
-
-function isApplication ({packageDetails}) {
-  return !!packageDetails.private;
-}
-
-async function scaffoldMonorepoType ({projectRoot}) {
-  info('Scaffolding Monorepo Details');
-
-  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
-
-  return {
-    nextSteps: [{
-      summary: 'Add packages to your new monorepo',
-      description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
-        + ' to scaffold new packages into your new monorepo'
-    }]
-  };
-}
-
-const defaultBuildDirectory = 'bin';
-
-async function scaffoldCliType ({
-  packageName,
-  visibility,
-  projectRoot,
-  dialect,
-  publishRegistry,
-  decisions,
-  packageBundlers
-}) {
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
-  const [bundlerResults, publishableResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.CLI}),
-    scaffoldPublishable({packageName, packageAccessLevel}),
-    mergeIntoExistingPackageJson({
-      projectRoot,
-      config: {
-        bin: {},
-        files: [`${defaultBuildDirectory}/`],
-        publishConfig: {
-          access: packageAccessLevel,
-          ...publishRegistry && {registry: publishRegistry}
-        }
-      }
-    })
-  ]);
-
-  return deepmerge.all([
-    publishableResults,
-    bundlerResults,
-    {
-      scripts: {
-        clean: `rimraf ./${defaultBuildDirectory}`,
-        prebuild: 'run-s clean',
-        build: 'npm-run-all --print-label --parallel build:*',
-        prepack: 'run-s build'
-      },
-      dependencies: ['update-notifier'],
-      devDependencies: ['rimraf'],
-      vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
-      buildDirectory: defaultBuildDirectory,
-      nextSteps: []
-    }
-  ]);
-}
-
-async function isCli ({packageDetails: {bin}}) {
-  return !!bin;
-}
-
-function liftCli ({projectRoot, packageDetails}) {
-  return liftPublishable({projectRoot, packageDetails});
-}
-
-async function scaffoldProjectType ({
-  projectType,
-  projectRoot,
-  projectName,
-  packageName,
-  packageManager,
-  visibility,
-  packageBundlers,
-  scope,
-  decisions,
-  dialect,
-  provideExample,
-  publishRegistry
-}) {
-  switch (projectType) {
-    case projectTypes$1.PACKAGE:
-      return scaffoldPackageType({
-        projectRoot,
-        projectName,
-        packageName,
-        packageManager,
-        visibility,
-        scope,
-        packageBundlers,
-        decisions,
-        dialect,
-        provideExample,
-        publishRegistry
-      });
-    case projectTypes$1.APPLICATION:
-      return scaffoldApplicationType({projectRoot});
-    case projectTypes$1.CLI:
-      return scaffoldCliType({
-        packageName,
-        visibility,
-        projectRoot,
-        dialect,
-        publishRegistry,
-        decisions,
-        packageBundlers
-      });
-    case projectTypes$1.MONOREPO:
-      return scaffoldMonorepoType({projectRoot});
-    case 'Other':
-      return {};
-    default:
-      throw new Error(`The project-type of ${projectType} is invalid`);
-  }
-}
-
-async function tester$1 ({projectRoot, packageDetails}) {
-  return await isPackage({projectRoot, packageDetails})
-    || await isCli({projectRoot, packageDetails})
-    || isApplication({projectRoot, packageDetails});
-}
-
-function vcsRepositoryHostedOnGithub(vcs) {
-  return vcs && 'github' === vcs.host;
-}
-
-async function lifter$2 ({projectRoot, packageDetails, vcs}) {
-  if (await isPackage({projectRoot, packageDetails})) return liftPackage$1({projectRoot, packageDetails});
-  if (await isCli({projectRoot, packageDetails})) return liftCli({projectRoot, packageDetails});
-
-  let homepage;
-
-  if (vcsRepositoryHostedOnGithub(vcs)) {
-    homepage = `https://github.com/${vcs.owner}/${vcs.name}#readme`;
-
-    await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
-  }
-
-  return {homepage};
-}
-
-var projectTypes = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldProjectType,
-  test: tester$1,
-  lift: lifter$2
-});
-
-function write ({projectRoot, config}) {
-  return write$2({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
-}
-
-async function addIgnore ({projectRoot, ignore}) {
-  if (ignore) {
-    const existingConfig = JSON.parse(await promises$1.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
-
-    await write({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
-  }
-}
-
-async function scaffoldBabel ({projectRoot, preset}) {
-  if (!preset) {
-    throw new Error('No babel preset provided. Cannot configure babel transpilation');
-  }
-
-  await write({projectRoot, config: {presets: [preset.name]}});
-
-  return {
-    devDependencies: ['@babel/register', preset.packageName],
-    eslint: {}
-  };
-}
-
-async function lifter$1 ({results, projectRoot}) {
-  await addIgnore({ignore: results.buildDirectory, projectRoot});
-
-  return {};
-}
-
-function predicate ({projectRoot}) {
-  return fileExists(`${projectRoot}/.babelrc.json`);
-}
-
-async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
-  const shareableTsConfigPackage = `${config.scope}/tsconfig`;
-
-  await writeConfigFile({
-    path: projectRoot,
-    name: 'tsconfig',
-    format: fileTypes.JSON,
-    config: {
-      $schema: 'https://json.schemastore.org/tsconfig',
-      extends: shareableTsConfigPackage,
-      compilerOptions: {
-        rootDir: 'src',
-        ...projectTypes$1.PACKAGE === projectType && {
-          outDir: 'lib',
-          declaration: true
-        }
-      },
-      include: ['src/**/*.ts'],
-      ...testFilenamePattern && {exclude: [testFilenamePattern]}
-    }
-  });
-
-  return {
-    eslint: {configs: ['typescript']},
-    devDependencies: ['typescript', shareableTsConfigPackage],
-    vcsIgnore: {files: ['tsconfig.tsbuildinfo']}
-  };
-}
-
-function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
-  switch (dialect) {
-    case dialects$1.BABEL:
-      return scaffoldBabel({preset: configs.babelPreset, projectRoot});
-    case dialects$1.TYPESCRIPT:
-      return scaffoldTypescript({config: configs.typescript, projectType, projectRoot, testFilenamePattern});
-    default:
-      return {};
-  }
-}
-
-var dialects = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scaffold: scaffoldDialect,
-  test: predicate,
-  lift: lifter$1
-});
-
-function buildPackageDetails ({
-  packageName,
-  dialect,
-  license,
-  author,
-  description
-}) {
-  return {
-    name: packageName,
-    description,
-    license,
-    type: dialects$1.ESM === dialect ? 'module' : 'commonjs',
-    author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
-    scripts: {}
-  };
-}
-
-async function scaffoldPackage ({
-  projectRoot,
-  dialect,
-  packageName,
-  license,
-  author,
-  description
-}) {
-  info('Configuring package.json');
-
-  const packageData = await buildPackageDetails({
-    packageName,
-    dialect,
-    license,
-    author,
-    description
-  });
-
-  await writePackageJson({projectRoot, config: packageData});
-
-  return {};
-}
-
-function sortPackageProperties (packageContents) {
-  return sortProperties(
-    packageContents,
-    [
-      'name',
-      'description',
-      'license',
-      'version',
-      'private',
-      'type',
-      'engines',
-      'author',
-      'contributors',
-      'repository',
-      'bugs',
-      'homepage',
-      'funding',
-      'keywords',
-      'runkitExampleFilename',
-      'exports',
-      'bin',
-      'main',
-      'module',
-      'types',
-      'sideEffects',
-      'scripts',
-      'files',
-      'publishConfig',
-      'packageManager',
-      'config',
-      'dependencies',
-      'devDependencies',
-      'peerDependencies'
-    ]
-  );
-}
-
-function defineVcsHostDetails (vcs, pathWithinParent) {
-  return vcs && 'github' === vcs.host && {
-    repository: pathWithinParent
-      ? {
-        type: 'git',
-        url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
-        directory: pathWithinParent
-      }
-      : `${vcs.owner}/${vcs.name}`,
-    bugs: `https://github.com/${vcs.owner}/${vcs.name}/issues`
-  };
-}
-
-const details = {
-  [packageManagers$1.NPM]: {
-    installationCommand: 'install',
-    installationFlags: {
-      [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
-      [PROD_DEPENDENCY_TYPE]: `save-${PROD_DEPENDENCY_TYPE}`,
-      exact: 'save-exact'
-    }
-  },
-  [packageManagers$1.YARN]: {
-    installationCommand: 'add',
-    installationFlags: {
-      [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
-      [PROD_DEPENDENCY_TYPE]: PROD_DEPENDENCY_TYPE,
-      exact: 'exact'
-    }
-  }
-};
-
-function getInstallationCommandFor(manager) {
-  return details[manager].installationCommand;
-}
-
-function getDependencyTypeFlag(manager, type) {
-  return details[manager].installationFlags[type];
-}
-
-function getExactFlag(manager) {
-  return details[manager].installationFlags.exact;
-}
-
-async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
-  if (dependencies.length) {
-    info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
-
-    await execa(
-      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${
-        getInstallationCommandFor(packageManager)
-      } ${[...new Set(dependencies)].join(' ')} --${getDependencyTypeFlag(packageManager, dependenciesType)}${
-        DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
-      }`,
-      {shell: true, cwd: projectRoot}
-    );
-  } else warn(`No ${dependenciesType} dependencies to install`);
-}
-
-function projectWillBeTested(scripts) {
-  return Object.keys(scripts).find(scriptName => scriptName.startsWith('test:'));
-}
-
-function projectShouldBeBuiltForVerification(scripts) {
-  return 'run-s build' === scripts['pregenerate:md'];
-}
-
-function updateTestScript (scripts) {
-  return {
-    ...scripts,
-    test: `npm-run-all --print-label${
-      projectShouldBeBuiltForVerification(scripts) ? ' build' : ''
-    } --parallel lint:*${
-      projectWillBeTested(scripts) ? ' --parallel test:*' : ''
-    }`
-  };
-}
-
-function liftScripts ({existingScripts, scripts}) {
-  return updateTestScript({...existingScripts, ...scripts});
-}
-
-async function liftPackage ({
-  projectRoot,
-  scripts,
-  tags,
-  dependencies,
-  devDependencies,
-  packageManager,
-  vcs,
-  pathWithinParent
-}) {
-  if (scripts || tags) {
-    info('Updating `package.json`', {level: 'secondary'});
-
-    const pathToPackageJson = `${projectRoot}/package.json`;
-
-    const existingPackageJsonContents = JSON.parse(await promises.readFile(pathToPackageJson, 'utf8'));
-
-    await writePackageJson({
-      projectRoot,
-      config: sortPackageProperties({
-        ...existingPackageJsonContents,
-        ...defineVcsHostDetails(vcs, pathWithinParent),
-        scripts: liftScripts({
-          existingScripts: existingPackageJsonContents.scripts,
-          scripts
-        }),
-        ...tags && {
-          keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
-        }
-      })
-    });
-  }
-
-  info('Installing 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 install dependencies');
-    error(e, {level: 'secondary'});
-  }
-}
-
-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 () {
-  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,
-  test: jsPackageManagerIsUsed,
-  lift: lifter,
-  determineCurrent: resolvePackageManager,
-  defineLockfilePath: determineLockfilePathFor
-});
-
-async function lift ({projectRoot, vcs, results, pathWithinParent}) {
-  info('Lifting JavaScript-specific details');
-
-  const {
-    scripts,
-    tags,
-    dependencies,
-    devDependencies,
-    packageManager: manager
-  } = results;
-
-  const [packageManager, packageContents] = await Promise.all([
-    resolvePackageManager({projectRoot, packageManager: manager}),
-    promises$1.readFile(`${projectRoot}/package.json`, 'utf8')
-  ]);
-
-  const enhancerResults = await applyEnhancers({
-    results,
-    enhancers: [
-      huskyPlugin,
-      enginesEnhancer,
-      coveragePlugin,
-      commitConventionPlugin,
-      dialects,
-      codeStylePlugin,
-      npmConfigPlugin,
-      projectTypes,
-      packageManagers
-    ],
-    options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents)}
-  });
-
-  await liftPackage(
-    deepmerge.all([
-      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
-      enhancerResults
-    ])
-  );
-
-  return enhancerResults;
-}
-
-const pluginSchema = joi.object({scaffolder: joi.func().arity(1).required()});
-const pluginMapSchema = joi.object().pattern(joi.string(), pluginSchema);
-
-const packageBundlersSchema = pluginMapSchema.default({});
-
-const applicationTypesSchema = pluginMapSchema.default({});
-
-const packageTypesSchema = pluginMapSchema.default({});
-
-const monorepoTypesSchema = pluginMapSchema.default({});
-
-function validate(options) {
-  const schema = joi.object().required()
-    .keys({
-      projectRoot: joi.string().required(),
-      projectName: joi.string().regex(/^@\w*\//, {invert: true}).required(),
-      visibility: joi.string().valid('Public', 'Private').required(),
-      license: joi.string().required(),
-      description: joi.string(),
-      pathWithinParent: joi.string()
-    })
-    .keys({
-      vcs: joi.object({
-        host: joi.string().required(),
-        owner: joi.string().required(),
-        name: joi.string().required()
-      })
-    })
-    .keys({
-      configs: joi.object({
-        eslint: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        typescript: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        prettier: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
-        commitlint: joi.object({
-          packageName: joi.string().required(),
-          name: joi.string().required()
-        }),
-        babelPreset: joi.object({
-          packageName: joi.string().required(),
-          name: joi.string().required()
-        }),
-        remark: joi.string()
-      }).default({})
-    })
-    .keys({
-      overrides: joi.object({
-        npmAccount: joi.string(),
-        author: joi.object({
-          name: joi.string().required(),
-          email: joi.string().email(),
-          url: joi.string().uri()
-        })
-      }).default({})
-    })
-    .keys({
-      ciServices: joi.object().pattern(/^/, joi.object({
-        scaffolder: joi.func().arity(1).required(),
-        public: joi.boolean(),
-        private: joi.boolean()
-      })).default({})
-    })
-    .keys({
-      hosts: joi.object().pattern(/^/, joi.object({
-        scaffolder: joi.func().arity(1).required(),
-        projectTypes: joi.array().items(joi.string().valid('static', 'node')).default([])
-      })).default({})
-    })
-    .keys({
-      applicationTypes: applicationTypesSchema,
-      packageTypes: packageTypesSchema,
-      monorepoTypes: monorepoTypesSchema
-    })
-    .keys({
-      unitTestFrameworks: unitTestFrameworksSchema,
-      packageBundlers: packageBundlersSchema
-    })
-    .keys({
-      decisions: joi.object()
-    })
-    .keys({registries: joi.object().pattern(joi.string(), joi.string().uri()).default({})});
-
-  return validateOptions(schema, options);
-}
-
-function buildDialectChoices ({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'}] : [],
-    {name: 'ESM-only (no transpilation)', value: dialects$1.ESM, short: 'esm'},
-    ...typescript ? [{name: 'TypeScript', value: dialects$1.TYPESCRIPT, short: 'ts'}] : []
-  ];
-}
-
-function projectIsCLI(answers) {
-  return projectTypes$1.CLI === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function projectIsPackage(answers) {
-  return projectTypes$1.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function projectIsApplication(answers) {
-  return projectTypes$1.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function packageShouldBeScoped(visibility, answers) {
-  return 'Private' === visibility || answers[questionNames$1.SHOULD_BE_SCOPED];
-}
-
-function willBePublishedToNpm(answers) {
-  return projectIsPackage(answers) || projectIsCLI(answers);
-}
-
-function shouldBeScopedPromptShouldBePresented(answers) {
-  return willBePublishedToNpm(answers);
-}
-
-function scopePromptShouldBePresentedFactory(visibility) {
-  return answers => willBePublishedToNpm(answers) && packageShouldBeScoped(visibility, answers);
-}
-
-function lintingPromptShouldBePresented({
-  [questionNames$2.UNIT_TESTS]: unitTested,
-  [questionNames$2.INTEGRATION_TESTS]: integrationTested
-}) {
-  return !unitTested && !integrationTested;
-}
-
-function scope(visibility) {
-  return input => {
-    if (!input && 'Private' === visibility) {
-      return 'Private packages must be scoped (https://docs.npmjs.com/private-modules/intro#setting-up-your-package)';
-    }
-
-    return true;
-  };
-}
-
-function authorQuestions({name, email, url}) {
-  return [
-    {
-      name: questionNames$1.AUTHOR_NAME,
-      message: 'What is the author\'s name?',
-      default: name
-    },
-    {
-      name: questionNames$1.AUTHOR_EMAIL,
-      message: 'What is the author\'s email?',
-      default: email
-    },
-    {
-      name: questionNames$1.AUTHOR_URL,
-      message: 'What is the author\'s website url?',
-      default: url
-    }
-  ];
-}
-
-async function prompt(
-  {npmAccount, author},
-  ciServices,
-  hosts,
-  visibility,
-  vcs,
-  decisions,
-  configs,
-  pathWithinParent
-) {
-  const npmConf$1 = npmConf();
-
-  let maybeLoggedInNpmUsername;
-  try {
-    maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
-  } catch (failedExecutionResult) {
-    if (!decisions[questionNames$1.SCOPE]) {
-      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 {
-    [questionNames$2.UNIT_TESTS]: unitTested,
-    [questionNames$2.INTEGRATION_TESTS]: integrationTested,
-    [questionNames$1.PROJECT_TYPE]: projectType,
-    [questionNames$2.CI_SERVICE]: ci,
-    [questionNames$1.HOST]: chosenHost,
-    [questionNames$1.SCOPE]: scope$1,
-    [questionNames$1.NODE_VERSION_CATEGORY]: nodeVersionCategory,
-    [questionNames$1.AUTHOR_NAME]: authorName,
-    [questionNames$1.AUTHOR_EMAIL]: authorEmail,
-    [questionNames$1.AUTHOR_URL]: authorUrl,
-    [questionNames$1.CONFIGURE_LINTING]: configureLinting,
-    [questionNames$1.PROVIDE_EXAMPLE]: provideExample,
-    [questionNames$1.PACKAGE_MANAGER]: packageManager,
-    [questionNames$1.DIALECT]: dialect
-  } = await prompt$1([
-    {
-      name: questionNames$1.DIALECT,
-      message: 'Which JavaScript dialect should this project follow?',
-      type: 'list',
-      choices: buildDialectChoices(configs),
-      default: 'babel'
-    },
-    ...pathWithinParent ? [] : [{
-      name: questionNames$1.NODE_VERSION_CATEGORY,
-      message: 'What node.js version should be used?',
-      type: 'list',
-      choices: ['LTS', 'Latest'],
-      default: 'LTS'
-    }],
-    {
-      name: questionNames$1.PACKAGE_MANAGER,
-      message: 'Which package manager will be used with this project?',
-      type: 'list',
-      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(projectTypes$1), new Separator(), 'Other'],
-      default: projectTypes$1.PACKAGE
-    },
-    ...'Private' === visibility ? [] : [{
-      name: questionNames$1.SHOULD_BE_SCOPED,
-      message: 'Should this package be scoped?',
-      type: 'confirm',
-      when: shouldBeScopedPromptShouldBePresented,
-      default: true
-    }],
-    {
-      name: questionNames$1.SCOPE,
-      message: 'What is the scope?',
-      when: scopePromptShouldBePresentedFactory(visibility),
-      validate: scope(visibility),
-      default: npmAccount || maybeLoggedInNpmUsername
-    },
-    ...authorQuestions(author || {
-      name: npmConf$1.get('init.author.name'),
-      email: npmConf$1.get('init.author.email'),
-      url: npmConf$1.get('init.author.url')
-    }),
-    ...questions(({vcs, ciServices, visibility, pathWithinParent})),
-    {
-      name: questionNames$1.CONFIGURE_LINTING,
-      message: 'Will there be source code that should be linted?',
-      type: 'confirm',
-      when: lintingPromptShouldBePresented
-    },
-    {
-      name: questionNames$1.PROVIDE_EXAMPLE,
-      message: 'Should an example be provided in the README?',
-      type: 'confirm',
-      when: projectIsPackage
-    },
-    {
-      name: questionNames$1.HOST,
-      type: 'list',
-      message: 'Where will the application be hosted?',
-      when: projectIsApplication,
-      choices: [...Object.keys(hosts), new Separator(), 'Other']
-    }
-  ], decisions);
-
-  return {
-    tests: {unit: unitTested, integration: integrationTested},
-    projectType,
-    ci,
-    chosenHost,
-    scope: scope$1,
-    nodeVersionCategory,
-    author: {name: authorName, email: authorEmail, url: authorUrl},
-    configureLinting: false !== configureLinting,
-    provideExample,
-    packageManager,
-    dialect
-  };
-}
-
-function scaffoldDocumentation ({projectTypeResults, packageManager}) {
-  return {
-    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`,
-    ...projectTypeResults.documentation,
-    contributing: `### Dependencies
-
-\`\`\`sh
-$ nvm install
-$ ${packageManager} install
-\`\`\`
-
-### Verification
-
-\`\`\`sh
-$ ${packageManager} test
-\`\`\``
-  };
-}
-
-async function determineLatestVersionOf(nodeVersionCategory) {
-  info('Determining version of node', {level: 'secondary'});
-
-  const {stdout: nvmLsOutput} = await execa(
-    `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
-    {shell: true}
-  );
-
-  const lsLines = nvmLsOutput.split('\n');
-  const lsLine = lsLines[lsLines.length - 2];
-
-  return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
-}
-
-function install(nodeVersionCategory) {
-  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
-
-  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
-  subprocess.stdout.pipe(process.stdout);
-  return subprocess;
-}
-
-async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
-  if (!nodeVersionCategory) return undefined;
-
-  const lowerCaseCategory = nodeVersionCategory.toLowerCase();
-  info(`Configuring ${lowerCaseCategory} version of node`);
-
-  const version = await determineLatestVersionOf(nodeVersionCategory);
-
-  await promises$1.writeFile(`${projectRoot}/.nvmrc`, version);
-
-  await install(nodeVersionCategory);
-
-  return version;
-}
-
-function nvmIsUsed ({projectRoot}) {
-  return fileExists(`${projectRoot}/.nvmrc`);
-}
-
-function buildBadgesDetails (contributors) {
-  return deepmerge.all(contributors).badges;
-}
-
-function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
-  return {
-    files: vcsIgnoreLists.files || [],
-    directories: ['/node_modules/', ...vcsIgnoreLists.directories || []]
-  };
-}
-
-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* `)}`);
-}
-
-async function chooseProjectTypePlugin ({types, projectType, decisions}) {
-  if (!Object.keys(types).length) return 'Other';
-
-  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 Separator(), 'Other']
-  }], decisions);
-
-  return answers[questionNames$1.PROJECT_TYPE_CHOICE];
-}
-
-async function scaffoldProjectTypePlugin ({
-  projectRoot,
-  projectType,
-  projectName,
-  packageName,
-  packageManager,
-  scope,
-  dialect,
-  tests,
-  decisions,
-  plugins
-}) {
-  const pluginsForProjectType = plugins[projectType];
-
-  if (!pluginsForProjectType) return {};
-
-  const chosenType = await chooseProjectTypePlugin({types: pluginsForProjectType, decisions, projectType});
-
-  return scaffoldChoice(
-    pluginsForProjectType,
-    chosenType,
-    {projectRoot, projectName, packageName, packageManager, scope, tests, dialect}
-  );
-}
-
-async function scaffoldTesting ({
-  projectRoot,
-  visibility,
-  tests: {unit, integration},
-  vcs,
-  unitTestFrameworks,
-  decisions,
-  dialect,
-  pathWithinParent
-}) {
-  const unitResults = unit
-    ? await scaffoldUnitTesting({
-      projectRoot,
-      visibility,
-      vcs,
-      frameworks: unitTestFrameworks,
-      decisions,
-      dialect,
-      pathWithinParent
-    })
-    : {};
-
-  return deepmerge({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 = [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'}
-  };
-}
-
-async function scaffoldLinting ({projectRoot, packageManager, registries}) {
-  return scaffoldLockfileLint({projectRoot, packageManager, registries});
-}
-
-async function scaffoldVerification({
-  projectRoot,
-  dialect,
-  visibility,
-  packageManager,
-  vcs,
-  registries,
-  tests,
-  unitTestFrameworks,
-  decisions,
-  pathWithinParent
-}) {
-  const [testingResults, lintingResults, huskyResults] = await Promise.all([
-    scaffoldTesting({
-      projectRoot,
-      tests,
-      visibility,
-      vcs,
-      unitTestFrameworks,
-      decisions,
-      dialect,
-      pathWithinParent
-    }),
-    scaffoldLinting({projectRoot, packageManager, registries, vcs, pathWithinParent}),
-    scaffold$3({projectRoot, packageManager, pathWithinParent})
-  ]);
-
-  return deepmerge.all([testingResults, lintingResults, huskyResults]);
-}
-
-async function scaffolder (options) {
-  info('Initializing JavaScript project');
-
-  const {
-    projectRoot,
-    projectName,
-    visibility,
-    license,
-    vcs,
-    description,
-    configs,
-    overrides,
-    ciServices,
-    hosts,
-    applicationTypes,
-    packageTypes,
-    packageBundlers,
-    monorepoTypes,
-    decisions,
-    unitTestFrameworks,
-    pathWithinParent,
-    registries
-  } = validate(options);
-
-  const {
-    tests,
-    projectType,
-    ci,
-    chosenHost,
-    scope,
-    nodeVersionCategory,
-    author,
-    configureLinting,
-    provideExample,
-    packageManager,
-    dialect
-  } = await prompt(overrides, ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
-
-  info('Writing project files', {level: 'secondary'});
-
-  const packageName = buildPackageName(projectName, scope);
-  await scaffoldPackage({
-    projectRoot,
-    dialect,
-    packageName,
-    license,
-    author,
-    description
-  });
-  const projectTypeResults = await scaffoldProjectType({
-    projectType,
-    projectRoot,
-    projectName,
-    packageName,
-    packageManager,
-    visibility,
-    applicationTypes,
-    packageTypes,
-    packageBundlers,
-    monorepoTypes,
-    scope,
-    tests,
-    vcs,
-    decisions,
-    dialect,
-    provideExample,
-    publishRegistry: registries.publish
-  });
-  const verificationResults = await scaffoldVerification({
-    projectRoot,
-    dialect,
-    visibility,
-    packageManager,
-    vcs,
-    registries,
-    tests,
-    unitTestFrameworks,
-    decisions,
-    pathWithinParent
-  });
-  const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([
-    scaffoldNodeVersion({projectRoot, nodeVersionCategory}),
-    scaffoldNpmConfig({projectType, projectRoot, registries}),
-    scaffoldDialect({
-      dialect,
-      configs,
-      projectRoot,
-      projectType,
-      testFilenamePattern: verificationResults.testFilenamePattern
-    }),
-    scaffoldCodeStyle({projectRoot, projectType, configs, vcs, configureLinting})
-  ]);
-  const projectTypePluginResults = await scaffoldProjectTypePlugin({
-    projectRoot,
-    projectType,
-    projectName,
-    packageName,
-    packageManager,
-    scope,
-    dialect,
-    tests,
-    decisions,
-    plugins: {
-      [projectTypes$1.PACKAGE]: packageTypes,
-      [projectTypes$1.APPLICATION]: applicationTypes,
-      [projectTypes$1.MONOREPO]: monorepoTypes
-    }
-  });
-  const mergedContributions = deepmerge.all([
-    ...(await Promise.all([
-      scaffoldChoice(
-        hosts,
-        chosenHost,
-        {buildDirectory: `./${projectTypeResults.buildDirectory}`, projectRoot, projectName, nodeVersion}
-      ),
-      scaffoldChoice(ciServices, ci, {projectRoot, vcs, visibility, projectType, projectName, nodeVersion, tests}),
-      scaffold$4({projectRoot, projectType, configs, pathWithinParent})
-    ])),
-    projectTypeResults,
-    verificationResults,
-    codeStyleResults,
-    npmResults,
-    dialectResults,
-    projectTypePluginResults
-  ]);
-
-  const liftResults = await lift({
-    results: deepmerge({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
-    projectRoot,
-    configs,
-    vcs,
-    pathWithinParent
-  });
-
-  return {
-    badges: buildBadgesDetails([mergedContributions, liftResults]),
-    documentation: scaffoldDocumentation({projectTypeResults, packageManager}),
-    tags: projectTypeResults.tags,
-    vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
-    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`,
-    projectDetails: {...liftResults.homepage && {homepage: liftResults.homepage}},
-    nextSteps: mergedContributions.nextSteps
-  };
-}
-
-async function tester ({projectRoot}) {
-  const [nvmFound, jsPackageManagerFound] = await Promise.all([
-    nvmIsUsed({projectRoot}),
-    jsPackageManagerIsUsed({projectRoot})
-  ]);
-
-  const jsProjectFound = nvmFound || jsPackageManagerFound;
-
-  if (jsProjectFound) info('JavaScript Project Detected');
-
-  return jsProjectFound;
-}
-
-const questionNames = {...questionNames$2, ...questionNames$1};
-
-export { lift, questionNames, scaffolder as scaffold, scaffoldUnitTesting, tester as test };
-//# sourceMappingURL=index.mjs.map