@jcoreio/toolchain 4.9.1 → 4.11.0

package/githooks/runHook.cjs

@@ -20,7 +20,7 @@ module.exports = async function runHook(hookName) {
     if (!hook) return
 
     if (typeof hook === 'function') {
-      await hook()
+      await hook(...process.argv.slice(2))
     } else if (hook) {
       await execa(hook, {
         cwd: projDir,
@@ -28,6 +28,8 @@ module.exports = async function runHook(hookName) {
       })
     }
   } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error(error)
     const { exitCode } = error
     process.exit(exitCode != null ? exitCode : 1)
     return

package/githooks.cjs

@@ -1,3 +1,41 @@
 module.exports = {
   'pre-commit': 'lint-staged',
+  'commit-msg': async (file) => {
+    const fs = require('./util/projectFs.cjs')
+    const parseCommitMessage = require('./util/parseCommitMessage.cjs')
+    const chalk = require('chalk')
+    const { monorepoSubpackageJsons } = require('./util/findUps.cjs')
+
+    let content
+    try {
+      content = await fs.readFile(file, 'utf8')
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(
+        chalk`{red ✖} failed to read commit message from ${file}`,
+        error.message
+      )
+      process.exit(1)
+    }
+    try {
+      const parsed = parseCommitMessage(content)
+      const scope = parsed.scope && parsed.scope[0]
+      if (
+        scope &&
+        monorepoSubpackageJsons &&
+        !monorepoSubpackageJsons.some((j) => scope === j.name)
+      ) {
+        throw new Error(
+          `invalid scope: ${scope} - scope must be the name of a package in this monorepo`
+        )
+      }
+      // eslint-disable-next-line no-console
+      console.error(chalk`{green ✔} validated commit message`)
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(chalk`{red ✖} invalid commit message: ${error.message}`)
+      process.exit(1)
+      return
+    }
+  },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcoreio/toolchain",
-  "version": "4.9.1",
+  "version": "4.11.0",
   "description": "base JS build toolchain",
   "repository": {
     "type": "git",

package/scripts/create.cjs

@@ -7,7 +7,7 @@ const parseRepositoryUrl = require('../util/parseRepositoryUrl.cjs')
 const markdownBadges = require('../util/markdownBadges.cjs')
 
 async function create(args = []) {
-  const prompt = require('prompts')
+  const prompt = require('../util/prompt.cjs')
 
   let monorepoPackageJson, monorepoProjectDir
   try {

package/scripts/init.cjs

@@ -35,7 +35,7 @@ async function init(args = []) {
 
   let selectedToolchains = [...toolchains]
   if (isInteractive) {
-    ;({ selectedToolchains } = await require('prompts')({
+    ;({ selectedToolchains } = await require('../uitl/prompt')({
       name: 'selectedToolchains',
       type: 'multiselect',
       message: 'Select toolchains to install',

package/scripts/install-optional-deps.cjs

@@ -0,0 +1,66 @@
+const execa = require('../util/execa.cjs')
+const {
+  packageJson,
+  isMonorepoRoot,
+  toolchainManaged,
+} = require('../util/findUps.cjs')
+
+async function installOptionalDeps() {
+  const choices = new Set()
+  const { dependencies = {}, devDependencies = {} } = packageJson
+  for (const dep of Object.keys({
+    ...toolchainManaged.optionalDependencies,
+    ...toolchainManaged.optionalDevDependencies,
+  })) {
+    if (!dependencies[dep] && !devDependencies[dep]) {
+      choices.add(dep)
+    }
+  }
+  if (!choices.size) {
+    // eslint-disable-next-line no-console
+    console.error('There are no additional optional dependencies to install')
+    process.exit(0)
+  }
+  const finalChoices = [...choices].sort()
+  const { selected } = await require('../util/prompt.cjs')({
+    name: 'selected',
+    type: 'multiselect',
+    message: 'Select optional dependencies to install',
+    choices: finalChoices,
+  })
+  const selectedSet = new Set(selected.map((i) => finalChoices[i]))
+
+  const selectedDeps = Object.keys(
+    toolchainManaged.optionalDependencies || {}
+  ).filter((dep) => selectedSet.has(dep))
+  const selectedDevDeps = Object.keys(
+    toolchainManaged.optionalDevDependencies || {}
+  ).filter((dep) => selectedSet.has(dep))
+
+  if (selectedDeps.length) {
+    await execa('pnpm', [
+      'add',
+      '--prefer-offline',
+      ...(isMonorepoRoot ? ['-w'] : []),
+      ...selectedDeps.map(
+        (dep) => `${dep}@${toolchainManaged.optionalDependencies[dep]}`
+      ),
+    ])
+  }
+  if (selectedDevDeps.length) {
+    await execa('pnpm', [
+      'add',
+      '-D',
+      '--prefer-offline',
+      ...(isMonorepoRoot ? ['-w'] : []),
+      ...selectedDevDeps.map(
+        (dep) => `${dep}@${toolchainManaged.optionalDevDependencies[dep]}`
+      ),
+    ])
+  }
+}
+
+exports.description =
+  'select and install optional toolchain-managed dependencies'
+
+exports.run = installOptionalDeps

package/scripts/toolchain.cjs

@@ -37,6 +37,7 @@ const scripts = toolchainConfig
         },
       },
       'install-git-hooks': require('./install-git-hooks.cjs'),
+      'install-optional-deps': require('./install-optional-deps.cjs'),
       ...(isMonorepoRoot ? { create: require('./create.cjs') } : {}),
       ...getPluginsObjectSync('scripts'),
       ...Object.fromEntries(

package/util/ParseError.cjs

@@ -0,0 +1,10 @@
+class ParseError extends Error {
+  constructor(message, from, to = from) {
+    super(message)
+    this.name = 'ParseError'
+    this.from = from
+    this.to = to
+  }
+}
+
+module.exports = ParseError

package/util/ParseState.cjs

@@ -0,0 +1,69 @@
+class ParseState {
+  constructor(
+    input,
+    {
+      /**
+       * The starting index (defaults to 0)
+       */
+      start = 0,
+      /**
+       * The ending index (defaults to input.length)
+       */
+      end = input.length,
+      /**
+       * Flags to add to all regexes
+       */
+      flags = 'g',
+    } = {}
+  ) {
+    this.input = input
+    this.start = start
+    this.index = start
+    this.end = end
+    this.flags = flags
+  }
+
+  get done() {
+    return this.index >= this.end
+  }
+
+  /**
+   * If pattern matches the input at the current index, returns the match,
+   * but doesn't advance the index.
+   */
+  peek(pattern) {
+    if (typeof pattern === 'string') pattern = toRegExp(pattern)
+    pattern = new RegExp(
+      pattern.source,
+      `${this.flags}${pattern.flags.replace(
+        new RegExp(`[${this.flags}]`, 'g'),
+        ''
+      )}`
+    )
+    pattern.lastIndex = this.index
+    const match = pattern.exec(this.input)
+    return match &&
+      match.index === this.index &&
+      match.index + match[0].length <= this.end
+      ? match
+      : undefined
+  }
+
+  /**
+   * If pattern matches the input at the current index, returns the match,
+   * and advances the index to the end of the match.
+   */
+  match(pattern) {
+    const match = this.peek(pattern)
+    if (match) {
+      this.index += match[0].length
+    }
+    return match
+  }
+}
+
+module.exports = ParseState
+
+function toRegExp(s, flags = '') {
+  return new RegExp(s.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&'), flags)
+}

package/util/confirm.cjs

@@ -7,7 +7,7 @@ module.exports = async function confirm({
 }) {
   return isInteractive
     ? (
-        await require('prompts')({
+        await require('./prompt')({
           type: 'confirm',
           message,
           initial,

package/util/hasJSSources.cjs

@@ -0,0 +1,6 @@
+const once = require('./once.cjs')
+const { globExists } = require('./glob.cjs')
+
+module.exports = once(async function hasJSSources() {
+  return await globExists('src/**/*.{js,cjs,mjs,jsx,cjsx,mjsx}')
+})

package/util/parseCommitMessage.cjs

@@ -0,0 +1,45 @@
+const ParseState = require('./ParseState.cjs')
+const ParseError = require('./ParseError.cjs')
+
+function parseCommitMessage(message) {
+  const state = new ParseState(message)
+  const type = state.match(/[^(:! )]+/)
+  if (!type || !/^[-a-z]+$/.test(type)) {
+    throw new ParseError(
+      'must begin with a type containing lowercase letters or - like `fix` or `feat`',
+      0
+    )
+  }
+  let scope
+  if (state.match('(')) {
+    scope = state.match(/[^)]+/)
+    if (!scope) {
+      throw new ParseError('a scope is required after (', state.index)
+    }
+    if (!state.match(')')) {
+      throw new ParseError('missing ) after scope', state.index)
+    }
+  }
+  const bang = state.match(/!/)
+  if (!state.match(':')) {
+    throw new ParseError('missing : after type/scope', state.index)
+  }
+  if (!state.match(/\s+/)) {
+    throw new ParseError('missing space after :', state.index)
+  }
+
+  const description = state.match(/.+$/m)
+  if (!description || !/\S/.test(description)) {
+    throw new ParseError('missing description', state.index)
+  }
+  if (!state.match(/\n\s*(\n|$)/) && !state.done) {
+    throw new ParseError(
+      'there must be a blank line before longer commit body',
+      state.index
+    )
+  }
+  const body = state.match(/(.|\n)+/)
+  return { type, scope, bang, description, body }
+}
+
+module.exports = parseCommitMessage

package/util/prompt.cjs

@@ -0,0 +1,15 @@
+const prompts = require('prompts')
+
+module.exports = async function prompt(...args) {
+  const handleKeypress = function (_chunk, key) {
+    if (key && key.name === 'c' && key.ctrl) {
+      process.kill(process.pid, 'SIGINT')
+    }
+  }
+  try {
+    process.stdin.on('keypress', handleKeypress)
+    return await prompts(...args)
+  } finally {
+    process.stdin.off('keypress', handleKeypress)
+  }
+}