@form8ion/javascript 12.1.0 → 12.3.0

package/lib/index.js

@@ -24,10 +24,10 @@ var camelcase = require('camelcase');
 var path = require('path');
 var filedirname = require('filedirname');
 var huskyPlugin = require('@form8ion/husky');
+var node_fs = require('node:fs');
 var ini = require('ini');
 var prettier = require('@form8ion/prettier');
 var eslintPlugin = require('@form8ion/eslint');
-var node_fs = require('node:fs');
 var sortProperties = require('sort-object-keys');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -250,7 +250,7 @@ async function scaffoldCodeStyle ({
   ].filter(Boolean)));
 }
 
-function lifter$3 (options) {
+function lifter$4 (options) {
   return core.applyEnhancers({options, enhancers: [eslintPlugin__namespace]});
 }
 
@@ -261,7 +261,7 @@ function tester$3 (options) {
 var codeStylePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
   scaffold: scaffoldCodeStyle,
-  lift: lifter$3,
+  lift: lifter$4,
   test: tester$3
 });
 
@@ -296,7 +296,7 @@ function tester$2 ({projectRoot}) {
   return core.fileExists(`${projectRoot}/.npmrc`);
 }
 
-async function lifter$2 ({projectRoot}) {
+async function lifter$3 ({projectRoot}) {
   const pathToConfig = `${projectRoot}/.npmrc`;
 
   const {
@@ -314,7 +314,7 @@ var npmConfigPlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
   scaffold: scaffoldNpmConfig,
   test: tester$2,
-  lift: lifter$2
+  lift: lifter$3
 });
 
 async function test({projectRoot}) {
@@ -428,14 +428,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 javascriptCore.mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
 
   return deepmerge__default["default"](
     await liftProvenance({packageDetails, projectRoot}),
     {
+      homepage,
       devDependencies: ['publint'],
       scripts: {'lint:publish': 'publint --strict'},
-      badges: defineBadges(packageName, pacakgeAccessLevel)
+      badges: defineBadges(packageName, packageAccessLevel)
     }
   );
 }
@@ -650,6 +654,10 @@ async function scaffoldApplicationType ({projectRoot}) {
   };
 }
 
+function isApplication ({packageDetails}) {
+  return !!packageDetails.private;
+}
+
 async function scaffoldMonorepoType ({projectRoot}) {
   cliMessages.info('Scaffolding Monorepo Details');
 
@@ -728,7 +736,6 @@ async function scaffoldProjectType ({
   visibility,
   packageBundlers,
   scope,
-  vcs,
   decisions,
   dialect,
   provideExample,
@@ -744,7 +751,6 @@ async function scaffoldProjectType ({
         visibility,
         scope,
         packageBundlers,
-        vcs,
         decisions,
         dialect,
         provideExample,
@@ -772,21 +778,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 javascriptCore.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}) {
@@ -795,7 +815,7 @@ function write ({projectRoot, config}) {
 
 async function addIgnore ({projectRoot, ignore}) {
   if (ignore) {
-    const existingConfig = JSON.parse(await fs.promises.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
+    const existingConfig = JSON.parse(await node_fs.promises.readFile(`${projectRoot}/.babelrc.json`, 'utf-8'));
 
     await write({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
   }
@@ -814,7 +834,7 @@ async function scaffoldBabel ({projectRoot, preset}) {
   };
 }
 
-async function lifter ({results, projectRoot}) {
+async function lifter$1 ({results, projectRoot}) {
   await addIgnore({ignore: results.buildDirectory, projectRoot});
 
   return {};
@@ -868,100 +888,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: (javascriptCore.projectTypes.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: javascriptCore.dialects.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
 }) {
   cliMessages.info('Configuring package.json');
 
   const packageData = await buildPackageDetails({
     packageName,
-    projectType,
     dialect,
     license,
-    vcs,
     author,
-    description,
-    pathWithinParent
+    description
   });
 
   await javascriptCore.writePackageJson({projectRoot, config: packageData});
 
-  return {homepage: packageData.homepage};
+  return {};
 }
 
 function sortPackageProperties (packageContents) {
@@ -1000,6 +967,19 @@ 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 = {
   [javascriptCore.packageManagers.NPM]: {
     installationCommand: 'install',
@@ -1046,13 +1026,38 @@ async function install$1 (dependencies, dependenciesType, projectRoot, packageMa
   } else cliMessages.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) {
     cliMessages.info('Updating `package.json`', {level: 'secondary'});
@@ -1065,7 +1070,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
         }
@@ -1084,21 +1093,65 @@ async function liftPackage ({
   }
 }
 
+function determineLockfilePathFor (packageManager) {
+  const lockfilePaths = {
+    [javascriptCore.packageManagers.NPM]: 'package-lock.json',
+    [javascriptCore.packageManagers.YARN]: 'yarn.lock'
+  };
+
+  return lockfilePaths[packageManager];
+}
+
+function npmIsUsed ({projectRoot}) {
+  return core.fileExists(`${projectRoot}/${determineLockfilePathFor(javascriptCore.packageManagers.NPM)}`);
+}
+
+function yarnIsUsed ({projectRoot}) {
+  return core.fileExists(`${projectRoot}/${determineLockfilePathFor(javascriptCore.packageManagers.YARN)}`);
+}
+
+async function jsPackageManagerIsUsed ({projectRoot}) {
+  const [npmFound, yarnFound] = await Promise.all([
+    npmIsUsed({projectRoot}),
+    yarnIsUsed({projectRoot})
+  ]);
+
+  return npmFound || yarnFound;
+}
+
+async function liftCorepack () {
+  await execa__default["default"]('corepack', ['use', 'npm@latest']);
+}
+
+async function lifter () {
+  await liftCorepack();
+
+  return {};
+}
+
 async function resolvePackageManager ({projectRoot, packageManager}) {
   if (packageManager) return packageManager;
 
-  if (await core.fileExists(`${projectRoot}/package-lock.json`)) {
+  if (await npmIsUsed({projectRoot})) {
     return javascriptCore.packageManagers.NPM;
   }
 
-  if (await core.fileExists(`${projectRoot}/yarn.lock`)) {
+  if (await yarnIsUsed({projectRoot})) {
     return javascriptCore.packageManagers.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}) {
   cliMessages.info('Lifting JavaScript-specific details');
 
   const {
@@ -1124,14 +1177,15 @@ async function lift ({projectRoot, vcs, results}) {
       dialects,
       codeStylePlugin,
       npmConfigPlugin,
-      projectTypes
+      projectTypes,
+      packageManagers
     ],
     options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents)}
   });
 
   await liftPackage(
     deepmerge__default["default"].all([
-      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager},
+      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
       enhancerResults
     ])
   );
@@ -1468,13 +1522,17 @@ async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
 
   const version = await determineLatestVersionOf(nodeVersionCategory);
 
-  await fs.promises.writeFile(`${projectRoot}/.nvmrc`, version);
+  await node_fs.promises.writeFile(`${projectRoot}/.nvmrc`, version);
 
   await install(nodeVersionCategory);
 
   return version;
 }
 
+function nvmIsUsed ({projectRoot}) {
+  return core.fileExists(`${projectRoot}/.nvmrc`);
+}
+
 function buildBadgesDetails (contributors) {
   return deepmerge__default["default"].all(contributors).badges;
 }
@@ -1569,15 +1627,6 @@ function buildAllowedHostsList ({packageManager, registries}) {
 
 const lockfileLintSupportedPackageManagers = [javascriptCore.packageManagers.NPM, javascriptCore.packageManagers.YARN];
 
-function determineLockfilePathFor(packageManager) {
-  const lockfilePaths = {
-    [javascriptCore.packageManagers.NPM]: 'package-lock.json',
-    [javascriptCore.packageManagers.YARN]: 'yarn.lock'
-  };
-
-  return lockfilePaths[packageManager];
-}
-
 function lockfileLintSupports(packageManager) {
   return lockfileLintSupportedPackageManagers.includes(packageManager);
 }
@@ -1683,16 +1732,13 @@ async function scaffolder (options) {
   cliMessages.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,
@@ -1775,7 +1821,8 @@ async function scaffolder (options) {
     results: deepmerge__default["default"]({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
     projectRoot,
     configs,
-    vcs
+    vcs,
+    pathWithinParent
   });
 
   return {
@@ -1784,19 +1831,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([
-    core.fileExists(`${projectRoot}/.nvmrc`),
-    core.fileExists(`${projectRoot}/package-lock.json`),
-    core.fileExists(`${projectRoot}/yarn.lock`)
+  const [nvmFound, jsPackageManagerFound] = await Promise.all([
+    nvmIsUsed({projectRoot}),
+    jsPackageManagerIsUsed({projectRoot})
   ]);
 
-  return nvmIsConfigured || packageLockExists || yarnLockExists;
+  return nvmFound || jsPackageManagerFound;
 }
 
 const questionNames = {...languageScaffolderPrompts.questionNames, ...questionNames$1};