@form8ion/javascript 1.1.3 → 2.1.0

package/lib/index.es.js

@@ -1,15 +1,85 @@
+import { questionNames as questionNames$2, questions } from '@travi/language-scaffolder-prompts';
 import deepmerge from 'deepmerge';
-import { validateOptions, scaffoldChoice } from '@form8ion/javascript-core';
-import { scaffold as scaffold$1 } from '@form8ion/codecov';
+import { validateOptions, scaffoldChoice, dialects, projectTypes, packageManagers } from '@form8ion/javascript-core';
+import { scaffold } from '@form8ion/codecov';
 import { promises } from 'fs';
-import * as joi from '@hapi/joi';
+import * as joi from 'joi';
 import { Separator } from 'inquirer';
-import { prompt } from '@form8ion/overridable-prompts';
+import { prompt as prompt$1 } from '@form8ion/overridable-prompts';
+import { warn, info } from '@travi/cli-messages';
+import { lift } from '@form8ion/lift-javascript';
+import { scaffold as scaffold$4 } from '@form8ion/commit-convention';
+import hoek from '@hapi/hoek';
+import execa from 'execa';
+import { stringify } from 'ini';
+import { EOL } from 'os';
+import validatePackageName from 'validate-npm-package-name';
+import { scaffold as scaffold$1 } from '@form8ion/rollup';
+import mustache from 'mustache';
+import camelcase from 'camelcase';
+import makeDir from 'make-dir';
+import touch from 'touch';
+import { resolve } from 'path';
+import { scaffold as scaffold$3 } from '@form8ion/husky';
+import { scaffold as scaffold$2 } from '@form8ion/eslint';
 
-function scaffold () {
-  return undefined;
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
 }
 
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+const questionNames$1 = {
+  UNIT_TEST_FRAMEWORK: 'unitTestFramework',
+  NODE_VERSION_CATEGORY: 'nodeVersionCategory',
+  PACKAGE_MANAGER: 'packageManager',
+  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',
+  DIALECT: 'dialect'
+};
+
 async function scaffoldC8 ({
   projectRoot
 }) {
@@ -34,13 +104,15 @@ async function scaffoldC8 ({
 async function scaffoldCoverage ({
   projectRoot,
   vcs,
-  visibility
+  visibility,
+  pathWithinParent
 }) {
   return deepmerge(await scaffoldC8({
     projectRoot
-  }), await scaffold$1({
+  }), await scaffold({
     vcs,
-    visibility
+    visibility,
+    pathWithinParent
   }));
 }
 
@@ -48,30 +120,27 @@ const unitTestFrameworksSchema = joi.object().required().pattern(/^/, joi.object
   scaffolder: joi.func().arity(1).required()
 }));
 
-const questionNames = {
-  UNIT_TEST_FRAMEWORK: 'unitTestFramework'
-};
-
 async function chooseFramework ({
   frameworks,
   decisions
 }) {
   if (!Object.keys(frameworks).length) return 'Other';
-  const answers = await prompt([{
-    name: questionNames.UNIT_TEST_FRAMEWORK,
+  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.UNIT_TEST_FRAMEWORK];
+  return answers[questionNames$1.UNIT_TEST_FRAMEWORK];
 }
 
-async function unit ({
+async function scaffoldUnitTesting ({
   projectRoot,
   frameworks,
   decisions,
   visibility,
-  vcs
+  vcs,
+  pathWithinParent
 }) {
   const validatedFrameworks = validateOptions(unitTestFrameworksSchema, frameworks);
   const [framework, coverage] = await Promise.all([chooseFramework({
@@ -82,7 +151,8 @@ async function unit ({
   })), scaffoldCoverage({
     projectRoot,
     vcs,
-    visibility
+    visibility,
+    pathWithinParent
   })]);
   return deepmerge.all([{
     scripts: {
@@ -91,5 +161,1313 @@ async function unit ({
   }, framework, coverage]);
 }
 
-export { questionNames, scaffold, unit as scaffoldUnitTesting, unitTestFrameworksSchema };
+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()
+      }),
+      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: joi.object().pattern(/^/, joi.object({
+      scaffolder: joi.func().arity(1).required()
+    })).default({}),
+    packageTypes: joi.object().pattern(/^/, joi.object({
+      scaffolder: joi.func().arity(1).required()
+    })).default({}),
+    monorepoTypes: joi.object().pattern(/^/, joi.object({
+      scaffolder: joi.func().arity(1).required()
+    }))
+  }).keys({
+    decisions: joi.object()
+  }).keys({
+    unitTestFrameworks: unitTestFrameworksSchema
+  }).keys({
+    registries: joi.object().pattern(joi.string(), joi.string().uri())
+  });
+  const {
+    error,
+    value
+  } = schema.validate(options);
+  hoek.assert(!error, error);
+  return value;
+}
+
+const npmConf = require('npm-conf');
+
+var npmConfFactory = npmConf;
+
+function buildDialectChoices ({
+  babelPreset,
+  typescript
+}) {
+  return [{
+    name: 'Common JS (no transpilation)',
+    value: dialects.COMMON_JS,
+    short: 'cjs'
+  }, ...(babelPreset ? [{
+    name: 'Modern JavaScript (transpiled)',
+    value: dialects.BABEL,
+    short: 'modern'
+  }] : []), {
+    name: 'ESM-only (no transpilation)',
+    value: dialects.ESM,
+    short: 'esm'
+  }, ...(typescript ? [{
+    name: 'TypeScript',
+    value: dialects.TYPESCRIPT,
+    short: 'ts'
+  }] : [])];
+}
+
+function projectIsPackage(answers) {
+  return projectTypes.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
+}
+
+function projectIsCLI(answers) {
+  return projectTypes.CLI === answers[questionNames$1.PROJECT_TYPE];
+}
+
+function projectIsApplication(answers) {
+  return projectTypes.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 = npmConfFactory();
+  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.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),
+    default: packageManagers.NPM
+  }, {
+    name: questionNames$1.PROJECT_TYPE,
+    message: 'What type of JavaScript project is this?',
+    type: 'list',
+    choices: [...Object.values(projectTypes), new Separator(), 'Other'],
+    default: projectTypes.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.get('init.author.name'),
+    email: npmConf.get('init.author.email'),
+    url: npmConf.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.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,
+    packageManager,
+    dialect
+  };
+}
+
+async function scaffoldBabel ({
+  projectRoot,
+  preset,
+  tests,
+  buildDirectory
+}) {
+  if (!preset) {
+    throw new Error('No babel preset provided. Cannot configure babel transpilation');
+  }
+
+  await promises.writeFile(`${projectRoot}/.babelrc`, JSON.stringify(_objectSpread2({
+    presets: [preset.name],
+    ignore: [`./${buildDirectory}/`]
+  }, tests.unit && {
+    env: {
+      test: {
+        plugins: ['istanbul']
+      }
+    }
+  })));
+  return {
+    devDependencies: ['@babel/register', preset.packageName, ...(tests.unit ? ['babel-plugin-istanbul'] : [])],
+    eslint: {}
+  };
+}
+
+async function scaffoldTypescript ({
+  config,
+  projectType,
+  projectRoot,
+  testFilenamePattern
+}) {
+  const eslintConfigs = ['typescript'];
+  const shareableTsConfigPackage = `${config.scope}/tsconfig`;
+  await promises.writeFile(`${projectRoot}/tsconfig.json`, JSON.stringify(_objectSpread2({
+    $schema: 'https://json.schemastore.org/tsconfig',
+    extends: shareableTsConfigPackage,
+    compilerOptions: _objectSpread2({
+      rootDir: 'src'
+    }, projectTypes.PACKAGE === projectType && {
+      outDir: 'lib',
+      declaration: true
+    }),
+    include: ['src/**/*.ts']
+  }, testFilenamePattern && {
+    exclude: [testFilenamePattern]
+  })));
+  return {
+    eslint: {
+      configs: eslintConfigs
+    },
+    eslintConfigs,
+    devDependencies: ['typescript', shareableTsConfigPackage],
+    packageProperties: {
+      types: 'lib/index.d.ts'
+    },
+    vcsIgnore: {
+      files: ['tsconfig.tsbuildinfo']
+    }
+  };
+}
+
+function scaffoldEsm () {
+  return {
+    packageProperties: {
+      engines: {
+        node: '>=12.20'
+      }
+    }
+  };
+}
+
+function scaffoldDialect ({
+  dialect,
+  projectType,
+  projectRoot,
+  configs,
+  tests,
+  buildDirectory,
+  testFilenamePattern
+}) {
+  switch (dialect) {
+    case dialects.BABEL:
+      return scaffoldBabel({
+        preset: configs.babelPreset,
+        projectRoot,
+        tests,
+        buildDirectory
+      });
+
+    case dialects.TYPESCRIPT:
+      return scaffoldTypescript({
+        config: configs.typescript,
+        projectType,
+        projectRoot,
+        testFilenamePattern
+      });
+
+    case dialects.ESM:
+      return scaffoldEsm();
+
+    default:
+      return {
+        eslint: {}
+      };
+  }
+}
+
+function projectWillNotBeConsumed(projectType) {
+  return projectTypes.APPLICATION === projectType || projectTypes.CLI === projectType;
+}
+
+async function scaffoldNpmConfig ({
+  projectRoot,
+  projectType,
+  registries
+}) {
+  await promises.writeFile(`${projectRoot}/.npmrc`, stringify(_objectSpread2(_objectSpread2({
+    'update-notifier': false,
+    'engine-strict': true
+  }, projectWillNotBeConsumed(projectType) && {
+    'save-exact': true
+  }), registries && Object.fromEntries(Object.entries(registries).map(([scope, url]) => [`@${scope}:registry`, url])))));
+  return {
+    scripts: {
+      'lint:peer': 'npm ls >/dev/null'
+    }
+  };
+}
+
+function buildDocumentationCommand (packageManager) {
+  if (packageManagers.NPM === packageManager) return 'npm run generate:md';
+  if (packageManagers.YARN === packageManager) return 'yarn generate:md';
+  throw new Error(`The ${packageManager} package manager is currently not supported. ` + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`);
+}
+
+function scaffoldDocumentation ({
+  projectTypeResults,
+  packageManager
+}) {
+  return _objectSpread2(_objectSpread2({
+    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.writeFile(`${projectRoot}/.nvmrc`, version);
+  await install(nodeVersionCategory);
+  return version;
+}
+
+function buildBadgesDetails (contributors) {
+  return deepmerge.all(contributors).badges;
+}
+
+function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
+  return {
+    files: vcsIgnoreLists.files || [],
+    directories: ['/node_modules/', ...(vcsIgnoreLists.directories || [])]
+  };
+}
+
+function projectWillBeTested(scripts) {
+  return Object.keys(scripts).find(scriptName => scriptName.startsWith('test:'));
+}
+
+function projectShouldBeBuiltForVerification(scripts) {
+  return 'run-s build' === scripts['pregenerate:md'];
+}
+
+function defineScripts(scripts) {
+  return {
+    test: `npm-run-all --print-label${projectShouldBeBuiltForVerification(scripts) ? ' build' : ''} --parallel lint:*${projectWillBeTested(scripts) ? ' --parallel test:*' : ''}`
+  };
+}
+
+function defineVcsHostDetails(vcs, packageType, packageName, 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`,
+    homepage: projectTypes.PACKAGE === packageType ? `https://npm.im/${packageName}` : `https://github.com/${vcs.owner}/${vcs.name}#readme`
+  };
+}
+
+function buildPackageDetails ({
+  packageName,
+  projectType,
+  dialect,
+  license,
+  vcs,
+  author,
+  description,
+  scripts,
+  packageProperties,
+  pathWithinParent
+}) {
+  return _objectSpread2(_objectSpread2(_objectSpread2({
+    name: packageName,
+    description,
+    license,
+    type: dialects.ESM === dialect ? 'module' : 'commonjs'
+  }, packageProperties), defineVcsHostDetails(vcs, projectType, packageName, pathWithinParent)), {}, {
+    author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
+    scripts: defineScripts(scripts)
+  });
+}
+
+async function scaffoldPackage ({
+  projectRoot,
+  projectType,
+  dialect,
+  scripts,
+  packageName,
+  license,
+  vcs,
+  author,
+  description,
+  packageProperties,
+  pathWithinParent
+}) {
+  info('Configuring package.json');
+  const packageData = await buildPackageDetails({
+    packageName,
+    projectType,
+    dialect,
+    license,
+    vcs,
+    author,
+    description,
+    scripts,
+    packageProperties,
+    pathWithinParent
+  });
+  await promises.writeFile(`${projectRoot}/package.json`, JSON.stringify(packageData));
+  return {
+    homepage: packageData.homepage
+  };
+}
+
+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 chooseApplicationType ({
+  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];
+}
+
+function getInstallationCommand(packageManager) {
+  if (packageManagers.NPM === packageManager) return 'npm install';
+  if (packageManagers.YARN === packageManager) return 'yarn add';
+  throw new Error(`The ${packageManager} package manager is currently not supported. ` + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`);
+}
+
+function scaffoldPackageDocumentation ({
+  scope,
+  packageName,
+  packageManager,
+  visibility
+}) {
+  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}
+\`\`\`
+
+### Example
+
+run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example`
+  };
+}
+
+function defineBadges (packageName, visibility) {
+  return {
+    consumer: _objectSpread2({}, 'Public' === visibility && {
+      npm: {
+        img: `https://img.shields.io/npm/v/${packageName}.svg`,
+        text: 'npm',
+        link: `https://www.npmjs.com/package/${packageName}`
+      }
+    }),
+    status: {}
+  };
+}
+
+function determinePathToTemplateFile (fileName) {
+  return resolve(__dirname, '..', 'templates', fileName);
+}
+
+const defaultBuildDirectory$2 = 'lib';
+
+async function createExample(projectRoot, projectName) {
+  return promises.writeFile(`${projectRoot}/example.js`, mustache.render(await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'), {
+    projectName: camelcase(projectName)
+  }));
+}
+
+async function buildDetailsForCommonJsProject({
+  projectRoot,
+  projectName
+}) {
+  await Promise.all([touch(`${projectRoot}/index.js`), promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)]);
+  return {};
+}
+
+async function buildDetails ({
+  projectRoot,
+  projectName,
+  visibility,
+  packageName,
+  dialect
+}) {
+  if (dialects.COMMON_JS === dialect) return buildDetailsForCommonJsProject({
+    projectRoot,
+    projectName
+  });
+  const pathToCreatedSrcDirectory = await makeDir(`${projectRoot}/src`);
+  const [rollupResults] = await Promise.all([scaffold$1({
+    projectRoot,
+    dialect,
+    projectType: projectTypes.PACKAGE
+  }), await createExample(projectRoot, projectName), touch(`${pathToCreatedSrcDirectory}/index.js`)]);
+  return deepmerge(rollupResults, {
+    devDependencies: ['rimraf'],
+    scripts: {
+      clean: `rimraf ./${defaultBuildDirectory$2}`,
+      prebuild: 'run-s clean',
+      build: 'npm-run-all --print-label --parallel build:*',
+      prepack: 'run-s build'
+    },
+    vcsIgnore: {
+      directories: [`/${defaultBuildDirectory$2}/`]
+    },
+    buildDirectory: defaultBuildDirectory$2,
+    badges: {
+      consumer: _objectSpread2({}, '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,
+  packageTypes,
+  tests,
+  decisions,
+  dialect
+}) {
+  info('Scaffolding Package Details');
+  const detailsForBuild = await buildDetails({
+    projectRoot,
+    projectName,
+    visibility,
+    packageName,
+    dialect
+  });
+
+  const details = _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, dialects.BABEL === dialect && _objectSpread2({
+    packageProperties: {
+      main: 'lib/index.cjs.js',
+      module: 'lib/index.es.js',
+      sideEffects: false,
+      files: ['lib/']
+    }
+  }, detailsForBuild)), dialects.ESM === dialect && _objectSpread2({
+    packageProperties: {
+      main: 'lib/index.es.js',
+      sideEffects: false,
+      files: ['lib/']
+    }
+  }, detailsForBuild)), dialects.TYPESCRIPT === dialect && _objectSpread2({
+    packageProperties: {
+      main: 'lib/index.cjs.js',
+      module: 'lib/index.es.js',
+      sideEffects: false,
+      files: ['lib/']
+    }
+  }, detailsForBuild)), dialects.COMMON_JS === dialect && _objectSpread2({
+    packageProperties: {
+      files: ['index.js']
+    }
+  }, detailsForBuild));
+
+  const chosenType = await chooseApplicationType({
+    types: packageTypes,
+    projectType: 'package',
+    decisions
+  });
+  const results = await scaffoldChoice(packageTypes, chosenType, {
+    projectRoot,
+    projectName,
+    packageName,
+    tests,
+    scope
+  });
+  return deepmerge.all([{
+    packageProperties: _objectSpread2({
+      files: ['example.js'],
+      publishConfig: {
+        access: 'Public' === visibility ? 'public' : 'restricted'
+      }
+    }, 'Public' === visibility && {
+      runkitExampleFilename: './example.js'
+    }),
+    documentation: scaffoldPackageDocumentation({
+      packageName,
+      visibility,
+      scope,
+      packageManager
+    }),
+    eslintConfigs: [],
+    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'
+    }],
+    scripts: {},
+    badges: defineBadges(packageName, visibility)
+  }, results, details]);
+}
+
+const defaultBuildDirectory$1 = 'lib';
+async function scaffoldApplicationType ({
+  applicationTypes,
+  projectRoot,
+  projectName,
+  packageName,
+  packageManager,
+  tests,
+  decisions
+}) {
+  info('Scaffolding Application Details');
+  const chosenType = await chooseApplicationType({
+    types: applicationTypes,
+    projectType: 'application',
+    decisions
+  });
+  const results = await scaffoldChoice(applicationTypes, chosenType, {
+    projectRoot,
+    projectName,
+    packageName,
+    packageManager,
+    tests
+  });
+  const buildDirectory = results.buildDirectory || defaultBuildDirectory$1;
+  return deepmerge({
+    scripts: {
+      clean: `rimraf ./${buildDirectory}`,
+      start: `node ./${buildDirectory}/index.js`,
+      prebuild: 'run-s clean'
+    },
+    dependencies: [],
+    devDependencies: ['rimraf'],
+    vcsIgnore: {
+      files: ['.env'],
+      directories: [`/${buildDirectory}/`]
+    },
+    buildDirectory,
+    packageProperties: {
+      private: true
+    },
+    eslintConfigs: [],
+    nextSteps: []
+  }, results);
+}
+
+async function scaffoldMonorepoType ({
+  monorepoTypes,
+  projectRoot,
+  packageManager,
+  decisions
+}) {
+  info('Scaffolding Monorepo Details');
+  const chosenType = await chooseApplicationType({
+    types: monorepoTypes,
+    projectType: projectTypes.MONOREPO,
+    decisions
+  });
+  const results = await scaffoldChoice(monorepoTypes, chosenType, {
+    projectRoot,
+    packageManager
+  });
+  return deepmerge({
+    eslintConfigs: [],
+    packageProperties: {
+      private: true
+    },
+    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'
+    }]
+  }, results);
+}
+
+const defaultBuildDirectory = 'bin';
+async function scaffoldCliType ({
+  packageName,
+  visibility,
+  projectRoot,
+  dialect
+}) {
+  const rollupResults = await scaffold$1({
+    projectRoot,
+    dialect,
+    projectType: projectTypes.CLI
+  });
+  return deepmerge(rollupResults, {
+    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,
+    badges: defineBadges(packageName, visibility),
+    packageProperties: {
+      version: '0.0.0-semantically-released',
+      bin: {},
+      files: [`${defaultBuildDirectory}/`],
+      publishConfig: {
+        access: 'Public' === visibility ? 'public' : 'restricted'
+      }
+    },
+    eslintConfigs: [],
+    nextSteps: []
+  });
+}
+
+async function scaffoldProjectType ({
+  projectType,
+  projectRoot,
+  projectName,
+  packageName,
+  packageManager,
+  visibility,
+  applicationTypes,
+  packageTypes,
+  monorepoTypes,
+  scope,
+  tests,
+  vcs,
+  decisions,
+  dialect
+}) {
+  switch (projectType) {
+    case projectTypes.PACKAGE:
+      return scaffoldPackageType({
+        projectRoot,
+        projectName,
+        packageName,
+        packageManager,
+        visibility,
+        scope,
+        packageTypes,
+        tests,
+        vcs,
+        decisions,
+        dialect
+      });
+
+    case projectTypes.APPLICATION:
+      return scaffoldApplicationType({
+        projectRoot,
+        projectName,
+        packageName,
+        packageManager,
+        applicationTypes,
+        tests,
+        decisions
+      });
+
+    case projectTypes.CLI:
+      return scaffoldCliType({
+        packageName,
+        visibility,
+        projectRoot,
+        dialect
+      });
+
+    case projectTypes.MONOREPO:
+      return scaffoldMonorepoType({
+        monorepoTypes,
+        projectRoot,
+        packageManager,
+        decisions
+      });
+
+    case 'Other':
+      return {
+        eslintConfigs: []
+      };
+
+    default:
+      throw new Error(`The project-type of ${projectType} is invalid`);
+  }
+}
+
+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: [],
+    eslintConfigs: []
+  }, unitResults);
+}
+
+async function scaffoldEslint ({
+  config,
+  projectRoot,
+  buildDirectory,
+  additionalConfiguration
+}) {
+  const {
+    scope
+  } = config;
+  const {
+    ignore
+  } = additionalConfiguration;
+  const ignores = deepmerge(ignore, {
+    directories: [`/${buildDirectory}/`]
+  });
+  return scaffold$2({
+    scope,
+    projectRoot,
+    ignore: {
+      directories: ignores.directories
+    }
+  });
+}
+
+async function scaffoldRemark ({
+  config,
+  projectRoot,
+  projectType,
+  vcs,
+  dialect
+}) {
+  await promises.writeFile(`${projectRoot}/.remarkrc.json`, JSON.stringify({
+    settings: {
+      listItemIndent: 1,
+      emphasis: '_',
+      strong: '_',
+      bullet: '*',
+      incrementListMarker: false
+    },
+    plugins: [config, ['remark-toc', {
+      tight: true
+    }], ...(projectTypes.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'
+    }
+  }, _objectSpread2({}, projectTypes.PACKAGE === projectType && _objectSpread2({
+    devDependencies: ['remark-usage']
+  }, dialects.COMMON_JS !== dialect && {
+    scripts: {
+      'pregenerate:md': 'run-s build'
+    }
+  })));
+}
+
+function scaffoldBanSensitiveFiles () {
+  return {
+    scripts: {
+      'lint:sensitive': 'ban'
+    },
+    devDependencies: ['ban-sensitive-files']
+  };
+}
+
+function determineLockfilePathFor(packageManager) {
+  if (packageManagers.NPM === packageManager) return 'package-lock.json';
+  if (packageManagers.YARN === packageManager) return 'yarn.lock';
+  throw new Error(`The ${packageManager} package manager is currently not supported. ` + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`);
+}
+
+async function scaffoldLockfileLint ({
+  projectRoot,
+  packageManager,
+  registries
+}) {
+  await promises.writeFile(`${projectRoot}/.lockfile-lintrc.json`, JSON.stringify({
+    path: determineLockfilePathFor(packageManager),
+    type: packageManager,
+    'validate-https': true,
+    'allowed-hosts': [packageManager, ...(registries ? Object.values(registries) : [])]
+  }));
+  return {
+    devDependencies: ['lockfile-lint'],
+    scripts: {
+      'lint:lockfile': 'lockfile-lint'
+    }
+  };
+}
+
+async function scaffoldLinting ({
+  projectRoot,
+  projectType,
+  packageManager,
+  dialect,
+  registries,
+  configs,
+  vcs,
+  configureLinting,
+  buildDirectory,
+  eslint
+}) {
+  return deepmerge.all(await Promise.all([scaffoldLockfileLint({
+    projectRoot,
+    packageManager,
+    registries
+  }), configs.eslint && configureLinting ? scaffoldEslint({
+    projectRoot,
+    config: configs.eslint,
+    buildDirectory,
+    additionalConfiguration: eslint
+  }) : {}, scaffoldRemark({
+    projectRoot,
+    projectType,
+    dialect,
+    vcs,
+    config: configs.remark || '@form8ion/remark-lint-preset'
+  }), vcs ? scaffoldBanSensitiveFiles() : {}]));
+}
+
+async function scaffoldVerification({
+  projectRoot,
+  projectType,
+  dialect,
+  visibility,
+  packageManager,
+  vcs,
+  configs,
+  registries,
+  configureLinting,
+  tests,
+  unitTestFrameworks,
+  decisions,
+  buildDirectory,
+  eslintConfigs,
+  pathWithinParent
+}) {
+  const [testingResults, huskyResults] = await Promise.all([scaffoldTesting({
+    projectRoot,
+    tests,
+    visibility,
+    vcs,
+    unitTestFrameworks,
+    decisions,
+    dialect,
+    pathWithinParent
+  }), scaffold$3({
+    projectRoot,
+    packageManager
+  })]);
+  const lintingResults = await scaffoldLinting({
+    projectRoot,
+    projectType,
+    packageManager,
+    dialect,
+    configs,
+    registries,
+    vcs,
+    configureLinting,
+    buildDirectory,
+    eslint: deepmerge.all([testingResults.eslint, {
+      configs: testingResults.eslintConfigs
+    }, {
+      configs: eslintConfigs
+    }])
+  });
+  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,
+    monorepoTypes,
+    decisions,
+    unitTestFrameworks,
+    pathWithinParent,
+    registries
+  } = validate(options);
+  const {
+    tests,
+    projectType,
+    ci,
+    chosenHost,
+    scope,
+    nodeVersionCategory,
+    author,
+    configureLinting,
+    packageManager,
+    dialect
+  } = await prompt(overrides, ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
+  info('Writing project files', {
+    level: 'secondary'
+  });
+  const packageName = buildPackageName(projectName, scope);
+  const projectTypeResults = await scaffoldProjectType({
+    projectType,
+    projectRoot,
+    projectName,
+    packageName,
+    packageManager,
+    visibility,
+    applicationTypes,
+    packageTypes,
+    monorepoTypes,
+    scope,
+    tests,
+    vcs,
+    decisions,
+    dialect
+  });
+  const verificationResults = await scaffoldVerification({
+    projectRoot,
+    projectType,
+    dialect,
+    packageManager,
+    visibility,
+    vcs,
+    configs,
+    registries,
+    configureLinting,
+    tests,
+    unitTestFrameworks,
+    decisions,
+    pathWithinParent,
+    buildDirectory: projectTypeResults.buildDirectory,
+    eslintConfigs: projectTypeResults.eslintConfigs
+  });
+  const [nodeVersion, npmResults, dialectResults] = await Promise.all([scaffoldNodeVersion({
+    projectRoot,
+    nodeVersionCategory
+  }), scaffoldNpmConfig({
+    projectType,
+    projectRoot,
+    registries
+  }), scaffoldDialect({
+    dialect,
+    configs,
+    projectRoot,
+    projectType,
+    tests,
+    buildDirectory: projectTypeResults.buildDirectory,
+    testFilenamePattern: verificationResults.testFilenamePattern
+  })]);
+  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, npmResults, dialectResults]);
+  const {
+    homepage: projectHomepage
+  } = await scaffoldPackage({
+    projectRoot,
+    projectType,
+    dialect,
+    packageName,
+    license,
+    vcs,
+    author,
+    description,
+    packageProperties: mergedContributions.packageProperties,
+    scripts: mergedContributions.scripts,
+    pathWithinParent
+  });
+  const liftResults = await lift({
+    results: deepmerge({
+      devDependencies: ['npm-run-all'],
+      packageManager
+    }, mergedContributions),
+    projectRoot,
+    configs
+  });
+  return {
+    badges: buildBadgesDetails([mergedContributions, liftResults]),
+    documentation: scaffoldDocumentation({
+      projectTypeResults,
+      packageManager
+    }),
+    tags: projectTypeResults.tags,
+    vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
+    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`,
+    projectDetails: _objectSpread2({}, projectHomepage && {
+      homepage: projectHomepage
+    }),
+    nextSteps: mergedContributions.nextSteps
+  };
+}
+
+const questionNames = _objectSpread2(_objectSpread2({}, questionNames$2), questionNames$1);
+
+export { questionNames, scaffolder as scaffold, scaffoldUnitTesting };
 //# sourceMappingURL=index.es.js.map