@form8ion/javascript 12.1.0 → 12.3.0

package/lib/index.mjs

@@ -1,7 +1,7 @@
 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, mergeIntoExistingPackageJson, dialects as dialects$1, writePackageJson, DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE } from '@form8ion/javascript-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';
@@ -22,11 +22,11 @@ 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 { promises as promises$1 } from 'node:fs';
 import sortProperties from 'sort-object-keys';
 
 const questionNames$1 = {
@@ -214,7 +214,7 @@ async function scaffoldCodeStyle ({
   ].filter(Boolean)));
 }
 
-function lifter$3 (options) {
+function lifter$4 (options) {
   return applyEnhancers({options, enhancers: [eslintPlugin]});
 }
 
@@ -225,7 +225,7 @@ function tester$3 (options) {
 var codeStylePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
   scaffold: scaffoldCodeStyle,
-  lift: lifter$3,
+  lift: lifter$4,
   test: tester$3
 });
 
@@ -260,7 +260,7 @@ function tester$2 ({projectRoot}) {
   return fileExists(`${projectRoot}/.npmrc`);
 }
 
-async function lifter$2 ({projectRoot}) {
+async function lifter$3 ({projectRoot}) {
   const pathToConfig = `${projectRoot}/.npmrc`;
 
   const {
@@ -278,7 +278,7 @@ var npmConfigPlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
   scaffold: scaffoldNpmConfig,
   test: tester$2,
-  lift: lifter$2
+  lift: lifter$3
 });
 
 async function test({projectRoot}) {
@@ -302,22 +302,22 @@ var enginesEnhancer = /*#__PURE__*/Object.freeze({
 });
 
 function buildDocumentationCommand (packageManager) {
-  if (packageManagers.NPM === packageManager) return 'npm run generate:md';
-  if (packageManagers.YARN === packageManager) return 'yarn generate:md';
+  if (packageManagers$1.NPM === packageManager) return 'npm run generate:md';
+  if (packageManagers$1.YARN === packageManager) return 'yarn generate:md';
 
   throw new Error(
     `The ${packageManager} package manager is currently not supported. `
-    + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`
+    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
   );
 }
 
 function getInstallationCommand(packageManager) {
-  if (packageManagers.NPM === packageManager) return 'npm install';
-  if (packageManagers.YARN === packageManager) return 'yarn add';
+  if (packageManagers$1.NPM === packageManager) return 'npm install';
+  if (packageManagers$1.YARN === packageManager) return 'yarn add';
 
   throw new Error(
     `The ${packageManager} package manager is currently not supported. `
-    + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`
+    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
   );
 }
 
@@ -392,14 +392,18 @@ async function liftProvenance ({projectRoot, packageDetails}) {
 }
 
 async function liftPublishable ({projectRoot, packageDetails}) {
-  const {name: packageName, publishConfig: {access: pacakgeAccessLevel}} = 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, pacakgeAccessLevel)
+      badges: defineBadges(packageName, packageAccessLevel)
     }
   );
 }
@@ -614,6 +618,10 @@ async function scaffoldApplicationType ({projectRoot}) {
   };
 }
 
+function isApplication ({packageDetails}) {
+  return !!packageDetails.private;
+}
+
 async function scaffoldMonorepoType ({projectRoot}) {
   info('Scaffolding Monorepo Details');
 
@@ -692,7 +700,6 @@ async function scaffoldProjectType ({
   visibility,
   packageBundlers,
   scope,
-  vcs,
   decisions,
   dialect,
   provideExample,
@@ -708,7 +715,6 @@ async function scaffoldProjectType ({
         visibility,
         scope,
         packageBundlers,
-        vcs,
         decisions,
         dialect,
         provideExample,
@@ -736,21 +742,35 @@ async function scaffoldProjectType ({
 }
 
 async function tester$1 ({projectRoot, packageDetails}) {
-  return await isPackage({projectRoot, packageDetails}) || isCli({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$1 ({projectRoot, packageDetails}) {
+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});
 
-  return {};
+  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$1
+  lift: lifter$2
 });
 
 function write ({projectRoot, config}) {
@@ -759,7 +779,7 @@ function write ({projectRoot, config}) {
 
 async function addIgnore ({projectRoot, ignore}) {
   if (ignore) {
-    const existingConfig = JSON.parse(await promises.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
+    const existingConfig = JSON.parse(await promises$1.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
 
     await write({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
   }
@@ -778,7 +798,7 @@ async function scaffoldBabel ({projectRoot, preset}) {
   };
 }
 
-async function lifter ({results, projectRoot}) {
+async function lifter$1 ({results, projectRoot}) {
   await addIgnore({ignore: results.buildDirectory, projectRoot});
 
   return {};
@@ -832,100 +852,47 @@ var dialects = /*#__PURE__*/Object.freeze({
   __proto__: null,
   scaffold: scaffoldDialect,
   test: predicate,
-  lift: lifter
+  lift: lifter$1
 });
 
-function scaffoldScripts () {
-  return {};
-}
-
-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});
-}
-
-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$1.PACKAGE === packageType)
-      ? `https://npm.im/${packageName}`
-      : `https://github.com/${vcs.owner}/${vcs.name}#readme`
-  };
-}
-
 function buildPackageDetails ({
   packageName,
-  projectType,
   dialect,
   license,
-  vcs,
   author,
-  description,
-  pathWithinParent
+  description
 }) {
   return {
     name: packageName,
     description,
     license,
     type: dialects$1.ESM === dialect ? 'module' : 'commonjs',
-    ...defineVcsHostDetails(vcs, projectType, packageName, pathWithinParent),
     author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
-    scripts: scaffoldScripts()
+    scripts: {}
   };
 }
 
 async function scaffoldPackage ({
   projectRoot,
-  projectType,
   dialect,
   packageName,
   license,
-  vcs,
   author,
-  description,
-  pathWithinParent
+  description
 }) {
   info('Configuring package.json');
 
   const packageData = await buildPackageDetails({
     packageName,
-    projectType,
     dialect,
     license,
-    vcs,
     author,
-    description,
-    pathWithinParent
+    description
   });
 
   await writePackageJson({projectRoot, config: packageData});
 
-  return {homepage: packageData.homepage};
+  return {};
 }
 
 function sortPackageProperties (packageContents) {
@@ -964,8 +931,21 @@ function sortPackageProperties (packageContents) {
   );
 }
 
+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.NPM]: {
+  [packageManagers$1.NPM]: {
     installationCommand: 'install',
     installationFlags: {
       [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
@@ -973,7 +953,7 @@ const details = {
       exact: 'save-exact'
     }
   },
-  [packageManagers.YARN]: {
+  [packageManagers$1.YARN]: {
     installationCommand: 'add',
     installationFlags: {
       [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
@@ -995,7 +975,7 @@ function getExactFlag(manager) {
   return details[manager].installationFlags.exact;
 }
 
-async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = packageManagers.NPM) {
+async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
   if (dependencies.length) {
     info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
 
@@ -1010,13 +990,38 @@ async function install$1 (dependencies, dependenciesType, projectRoot, packageMa
   } 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
+  packageManager,
+  vcs,
+  pathWithinParent
 }) {
   if (scripts || tags) {
     info('Updating `package.json`', {level: 'secondary'});
@@ -1029,7 +1034,11 @@ async function liftPackage ({
       projectRoot,
       config: sortPackageProperties({
         ...existingPackageJsonContents,
-        scripts: liftScripts({existingScripts: existingPackageJsonContents.scripts, scripts}),
+        ...defineVcsHostDetails(vcs, pathWithinParent),
+        scripts: liftScripts({
+          existingScripts: existingPackageJsonContents.scripts,
+          scripts
+        }),
         ...tags && {
           keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
         }
@@ -1048,21 +1057,65 @@ async function liftPackage ({
   }
 }
 
+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 fileExists(`${projectRoot}/package-lock.json`)) {
-    return packageManagers.NPM;
+  if (await npmIsUsed({projectRoot})) {
+    return packageManagers$1.NPM;
   }
 
-  if (await fileExists(`${projectRoot}/yarn.lock`)) {
-    return packageManagers.YARN;
+  if (await yarnIsUsed({projectRoot})) {
+    return packageManagers$1.YARN;
   }
 
   throw new Error('Package-manager could not be determined');
 }
 
-async function lift ({projectRoot, vcs, results}) {
+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 {
@@ -1088,14 +1141,15 @@ async function lift ({projectRoot, vcs, results}) {
       dialects,
       codeStylePlugin,
       npmConfigPlugin,
-      projectTypes
+      projectTypes,
+      packageManagers
     ],
     options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents)}
   });
 
   await liftPackage(
     deepmerge.all([
-      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager},
+      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
       enhancerResults
     ])
   );
@@ -1317,8 +1371,8 @@ async function prompt(
       name: questionNames$1.PACKAGE_MANAGER,
       message: 'Which package manager will be used with this project?',
       type: 'list',
-      choices: Object.values(packageManagers),
-      default: packageManagers.NPM
+      choices: Object.values(packageManagers$1),
+      default: packageManagers$1.NPM
     },
     {
       name: questionNames$1.PROJECT_TYPE,
@@ -1432,13 +1486,17 @@ async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
 
   const version = await determineLatestVersionOf(nodeVersionCategory);
 
-  await promises.writeFile(`${projectRoot}/.nvmrc`, version);
+  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;
 }
@@ -1531,16 +1589,7 @@ function buildAllowedHostsList ({packageManager, registries}) {
   ];
 }
 
-const lockfileLintSupportedPackageManagers = [packageManagers.NPM, packageManagers.YARN];
-
-function determineLockfilePathFor(packageManager) {
-  const lockfilePaths = {
-    [packageManagers.NPM]: 'package-lock.json',
-    [packageManagers.YARN]: 'yarn.lock'
-  };
-
-  return lockfilePaths[packageManager];
-}
+const lockfileLintSupportedPackageManagers = [packageManagers$1.NPM, packageManagers$1.YARN];
 
 function lockfileLintSupports(packageManager) {
   return lockfileLintSupportedPackageManagers.includes(packageManager);
@@ -1647,16 +1696,13 @@ async function scaffolder (options) {
   info('Writing project files', {level: 'secondary'});
 
   const packageName = buildPackageName(projectName, scope);
-  const {homepage: projectHomepage} = await scaffoldPackage({
+  await scaffoldPackage({
     projectRoot,
-    projectType,
     dialect,
     packageName,
     license,
-    vcs,
     author,
-    description,
-    pathWithinParent
+    description
   });
   const projectTypeResults = await scaffoldProjectType({
     projectType,
@@ -1739,7 +1785,8 @@ async function scaffolder (options) {
     results: deepmerge({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
     projectRoot,
     configs,
-    vcs
+    vcs,
+    pathWithinParent
   });
 
   return {
@@ -1748,19 +1795,18 @@ async function scaffolder (options) {
     tags: projectTypeResults.tags,
     vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
     verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`,
-    projectDetails: {...projectHomepage && {homepage: projectHomepage}},
+    projectDetails: {...liftResults.homepage && {homepage: liftResults.homepage}},
     nextSteps: mergedContributions.nextSteps
   };
 }
 
 async function tester ({projectRoot}) {
-  const [nvmIsConfigured, packageLockExists, yarnLockExists] = await Promise.all([
-    fileExists(`${projectRoot}/.nvmrc`),
-    fileExists(`${projectRoot}/package-lock.json`),
-    fileExists(`${projectRoot}/yarn.lock`)
+  const [nvmFound, jsPackageManagerFound] = await Promise.all([
+    nvmIsUsed({projectRoot}),
+    jsPackageManagerIsUsed({projectRoot})
   ]);
 
-  return nvmIsConfigured || packageLockExists || yarnLockExists;
+  return nvmFound || jsPackageManagerFound;
 }
 
 const questionNames = {...questionNames$2, ...questionNames$1};