@jcoreio/toolchain 4.0.1 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcoreio/toolchain",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "base JS build toolchain",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
   "bugs": {
     "url": "https://github.com/jcoreio/toolchains/issues"
   },
-  "homepage": "https://github.com/jcoreio/toolchains/tree/beta/packages/base",
+  "homepage": "https://github.com/jcoreio/toolchains/tree/main/packages/base",
   "dependencies": {
     "@jcoreio/eslint-plugin-implicit-dependencies": "^1.1.1",
     "chalk": "^4.0.0",

package/plugins/getConfigFiles.cjs

@@ -2,6 +2,7 @@ const { name } = require('../package.json')
 const dedent = require('dedent-js')
 const fs = require('../util/projectFs.cjs')
 const JSON5 = require('json5')
+const { isMonorepoSubpackage } = require('../util/findUps.cjs')
 const getPluginsArraySync = require('../util/getPluginsArraySync.cjs')
 
 async function getRootEslintConfig() {
@@ -60,7 +61,7 @@ module.exports = [
       },
     }
     for (const file of [
-      'githooks.cjs',
+      ...(isMonorepoSubpackage ? [] : ['githooks.cjs']),
       'lint-staged.config.cjs',
       'prettier.config.cjs',
     ]) {

package/scripts/create.cjs

@@ -0,0 +1,259 @@
+const path = require('path')
+const execa = require('../util/execa.cjs')
+const ChdirFs = require('../util/ChdirFs.cjs')
+const pkg = require('../package.json')
+const dedent = require('dedent-js')
+const parseRepositoryUrl = require('../util/parseRepositoryUrl.cjs')
+
+async function create(args = []) {
+  const prompt = require('prompts')
+
+  let monorepoPackageJson, monorepoProjectDir
+  try {
+    ;({
+      monorepoPackageJson,
+      monorepoProjectDir,
+    } = require('../util/findUps.cjs'))
+  } catch (error) {
+    if (!error.message.startsWith('failed to find project package.json')) {
+      throw error
+    }
+  }
+
+  const required = (s) => Boolean(s) || 'required'
+
+  let defaultAuthor
+  if (monorepoPackageJson) defaultAuthor = monorepoPackageJson.author
+  else {
+    try {
+      defaultAuthor = (
+        await execa('git', ['config', 'user.name'], {
+          stdio: 'pipe',
+          maxBuffer: 1024,
+          encoding: 'utf8',
+        })
+      ).stdout.trim()
+    } catch (error) {
+      // ignore
+    }
+  }
+
+  const questions = [
+    {
+      type: 'text',
+      name: 'directory',
+      message: 'Destination directory:',
+      validate: required,
+    },
+    {
+      type: 'text',
+      name: 'name',
+      message: 'Package name:',
+      initial: (prev, { directory }) => path.basename(directory),
+      validate: required,
+    },
+    {
+      type: 'text',
+      name: 'description',
+      message: 'Package description:',
+      validate: required,
+    },
+    {
+      type: 'text',
+      name: 'author',
+      initial: defaultAuthor,
+      message: 'Package author:',
+      validate: required,
+    },
+    {
+      type: 'text',
+      name: 'keywords',
+      message: 'Package keywords:',
+      format: (text) => (text || '').split(/\s*,\s*|\s+/g),
+    },
+    ...(monorepoPackageJson
+      ? []
+      : [
+          {
+            type: 'text',
+            name: 'organization',
+            initial: (prev, { name }) => {
+              const match = /^@(.*?)\//.exec(name)
+              if (match) return match[1]
+            },
+            message: 'GitHub organization:',
+            validate: required,
+          },
+          {
+            type: 'text',
+            name: 'repo',
+            message: 'GitHub repo:',
+            initial: (prev, { name }) => name.replace(/^@(.*?)\//, ''),
+            validate: required,
+          },
+        ]),
+    {
+      type: 'select',
+      name: 'license',
+      message: 'License',
+      choices: Object.entries(licenses).map(([value, { title }]) => ({
+        title,
+        value,
+      })),
+    },
+    {
+      type: 'text',
+      name: 'copyrightHolder',
+      message: 'Copyright holder:',
+      initial: (prev, { author }) => author,
+      validate: required,
+    },
+    {
+      name: 'ready',
+      type: 'confirm',
+      initial: true,
+      message: 'Ready to go?',
+    },
+  ]
+
+  let answers
+  do {
+    answers = await prompt(questions)
+    for (const question of questions) {
+      const { name, transformer } = question
+      if (name !== 'ready') {
+        const answer = answers[name]
+        question.initial = transformer ? transformer(answer) : answer
+      }
+    }
+  } while (!answers.ready)
+
+  const {
+    directory,
+    name,
+    description,
+    author,
+    keywords,
+    license,
+    copyrightHolder,
+  } = answers
+
+  const { organization, repo } = monorepoPackageJson
+    ? parseRepositoryUrl(monorepoPackageJson.repository.url)
+    : answers
+
+  const cwd = path.resolve(directory)
+
+  await require('fs-extra').mkdirs(path.join(cwd, 'src'))
+
+  const fs = ChdirFs(cwd)
+
+  const subpackagePath = monorepoProjectDir
+    ? path.relative(monorepoProjectDir, cwd)
+    : undefined
+
+  const branch = subpackagePath
+    ? (
+        await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+          stdio: 'pipe',
+          encoding: 'utf8',
+          maxBuffer: 1024,
+        })
+      ).stdout.trim()
+    : ''
+
+  const packageJson = {
+    name,
+    description,
+    repository: {
+      type: 'git',
+      url: `https://github.com/${organization}/${repo}.git`,
+      ...(subpackagePath ? { directory: subpackagePath } : {}),
+    },
+    homepage: `https://github.com/${organization}/${repo}${
+      subpackagePath ? `/tree/${branch}/${subpackagePath}` : ''
+    }`,
+    bugs: {
+      url: `https://github.com/${organization}/${repo}/issues`,
+    },
+    author,
+    license,
+    keywords,
+  }
+
+  await fs.writeJson('package.json', packageJson, { spaces: 2 })
+
+  const files = {
+    'README.md': dedent`
+      # ${name}
+
+      ${description}
+
+      [![CircleCI](https://circleci.com/gh/${organization}/${repo}.svg?style=svg)](https://circleci.com/gh/${organization}/${repo})
+      [![Coverage Status](https://codecov.io/gh/${organization}/${repo}/branch/master/graph/badge.svg)](https://codecov.io/gh/${organization}/${repo})
+      [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+      [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+      [![npm version](https://badge.fury.io/js/${encodeURIComponent(
+        name
+      )}.svg)](https://badge.fury.io/js/${encodeURIComponent(name)}) 
+    `,
+    'LICENSE.md': (
+      await fs.readFile(require.resolve(`./licenses/${license}.md`), 'utf8')
+    )
+      .replace(/<YEAR>/g, String(new Date().getFullYear()))
+      .replace(/<COPYRIGHT HOLDER>/g, copyrightHolder),
+  }
+  await Promise.all(
+    Object.entries(files).map(async ([name, content]) => {
+      const file = path.resolve(cwd, name)
+      await fs.writeFile(file, content, 'utf8')
+      // eslint-disable-next-line no-console
+      console.error(`wrote ${path.relative(process.cwd(), file)}`)
+    })
+  )
+
+  if (!monorepoPackageJson) {
+    await execa('git', ['init'], { cwd })
+    await execa(
+      'git',
+      ['remote', 'add', 'origin', packageJson.repository.url],
+      {
+        cwd,
+      }
+    )
+  }
+
+  const isTest = Boolean(process.env.JCOREIO_TOOLCHAIN_SELF_TEST)
+
+  await execa(
+    'pnpm',
+    [
+      'add',
+      '-D',
+      '--prefer-offline',
+      `${pkg.name}@${isTest ? 'workspace:*' : pkg.version}`,
+    ],
+    { cwd }
+  )
+  await execa('pnpm', ['exec', 'tc', 'init'], { cwd })
+
+  if (!monorepoPackageJson) {
+    await execa('git', ['add', '.'], { cwd })
+    await execa(
+      'git',
+      ['commit', '-m', 'chore: initial commit from tc create'],
+      {
+        cwd,
+      }
+    )
+  }
+}
+
+exports.description = 'create a new toolchain project'
+exports.run = create
+
+const licenses = {
+  MIT: {
+    title: 'The MIT License',
+  },
+}

package/scripts/init.cjs

@@ -69,7 +69,6 @@ async function init(args = []) {
   await execa('pnpm', [
     'add',
     '-D',
-    '--no-optional',
     '--prefer-offline',
     ...(isMonorepoRoot ? ['-w'] : []),
     isTest ? '../packages/base' : `${name}@^${version}`,

package/scripts/licenses/MIT.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <YEAR> <COPYRIGHT HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/scripts/migrate.cjs

@@ -34,7 +34,6 @@ async function migrate(args = []) {
   if (!args.includes('--config-only')) {
     await execa('pnpm', [
       'i',
-      '--no-optional',
       '--prefer-offline',
       '--fix-lockfile',
       ...(isMonorepoRoot ? ['-w'] : []),

package/scripts/prepublish.cjs

@@ -1,12 +1,17 @@
 const execa = require('../util/execa.cjs')
+const { isMonorepoRoot, packageJson } = require('../util/findUps.cjs')
 
 exports.run = async function (args = []) {
-  const { scripts } = require('./toolchain.cjs')
-  await execa('tc', ['check'])
-  if (scripts.coverage) await execa('tc', ['coverage'])
-  if (scripts['test:esm']) await execa('tc', ['test:esm'])
-  await execa('tc', ['build'])
-  await execa('tc', ['build:smoke-test'])
+  if (isMonorepoRoot && packageJson.name !== '@jcoreio/toolchains') {
+    await execa('pnpm', ['run', '-r', 'prepublish'])
+  } else {
+    const { scripts } = require('./toolchain.cjs')
+    await execa('tc', ['check'])
+    if (scripts.coverage) await execa('tc', ['coverage'])
+    if (scripts['test:esm']) await execa('tc', ['test:esm'])
+    await execa('tc', ['build'])
+    await execa('tc', ['build:smoke-test'])
+  }
 }
 
 exports.description = 'run check, coverage, and build'

package/scripts/toolchain.cjs

@@ -3,45 +3,57 @@
 const { name, version } = require('../package.json')
 const chalk = require('chalk')
 const getPluginsObjectSync = require('../util/getPluginsObjectSync.cjs')
-const { toolchainConfig } = require('../util/findUps.cjs')
 const execa = require('../util/execa.cjs')
 
-const scripts = {
-  migrate: require('./migrate.cjs'),
-  build: require('./build.cjs'),
-  'build:smoke-test': require('./smokeTestBuild.cjs'),
-  check: require('./check.cjs'),
-  clean: require('./clean.cjs'),
-  format: require('./format.cjs'),
-  init: require('./init.cjs'),
-  preinstall: require('./preinstall.cjs'),
-  lint: require('./lint.cjs'),
-  'lint:fix': require('./lint-fix.cjs'),
-  'open:coverage': require('./open-coverage.cjs'),
-  prepublish: require('./prepublish.cjs'),
-  upgrade: require('./upgrade.cjs'),
-  version: {
-    description: `print version of ${name}`,
-    run: () => {
-      // eslint-disable-next-line no-console
-      console.log(`${name}@${version}`)
-    },
-  },
-  'install-git-hooks': require('./install-git-hooks.cjs'),
-  ...getPluginsObjectSync('scripts'),
-  ...Object.fromEntries(
-    Object.entries(toolchainConfig.scripts || {}).map(([name, script]) => [
-      name,
-      typeof script === 'string'
-        ? {
-            run: (args = []) =>
-              execa([script, ...args].join(' '), { shell: true }),
-            description: script,
-          }
-        : script,
-    ])
-  ),
+let toolchainConfig, isMonorepoRoot
+try {
+  ;({ toolchainConfig, isMonorepoRoot } = require('../util/findUps.cjs'))
+} catch (error) {
+  if (!error.message.startsWith('failed to find project package.json')) {
+    throw error
+  }
 }
+const scripts = toolchainConfig
+  ? {
+      migrate: require('./migrate.cjs'),
+      build: require('./build.cjs'),
+      'build:smoke-test': require('./smokeTestBuild.cjs'),
+      check: require('./check.cjs'),
+      clean: require('./clean.cjs'),
+      format: require('./format.cjs'),
+      init: require('./init.cjs'),
+      preinstall: require('./preinstall.cjs'),
+      lint: require('./lint.cjs'),
+      'lint:fix': require('./lint-fix.cjs'),
+      'open:coverage': require('./open-coverage.cjs'),
+      prepublish: require('./prepublish.cjs'),
+      upgrade: require('./upgrade.cjs'),
+      version: {
+        description: `print version of ${name}`,
+        run: () => {
+          // eslint-disable-next-line no-console
+          console.log(`${name}@${version}`)
+        },
+      },
+      'install-git-hooks': require('./install-git-hooks.cjs'),
+      ...(isMonorepoRoot ? { create: require('./create.cjs') } : {}),
+      ...getPluginsObjectSync('scripts'),
+      ...Object.fromEntries(
+        Object.entries(toolchainConfig.scripts || {}).map(([name, script]) => [
+          name,
+          typeof script === 'string'
+            ? {
+                run: (args = []) =>
+                  execa([script, ...args].join(' '), { shell: true }),
+                description: script,
+              }
+            : script,
+        ])
+      ),
+    }
+  : {
+      create: require('./create.cjs'),
+    }
 
 exports.scripts = scripts
 

package/scripts/upgrade.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { packageJson, isMonorepoRoot } = require('../util/findUps.cjs')
+const { packageJson, monorepoProjectDir } = require('../util/findUps.cjs')
 const execa = require('../util/execa.cjs')
 const { name } = require('../package.json')
 
@@ -19,18 +19,27 @@ async function upgrade([version] = []) {
     ).stdout.trim()
   }
 
-  await execa('pnpm', [
-    'add',
-    '-D',
-    '--no-optional',
-    '--prefer-offline',
-    ...(isMonorepoRoot ? ['-w'] : []),
-    isTest ? '../packages/base' : `${name}@^${version}`,
-    ...(isTest
-      ? toolchains.map((t) => t.replace(`${name}-`, '../packages/'))
-      : toolchains.map((t) => `${t}@^${version}`)),
-  ])
-  await execa('tc', ['migrate'])
+  await execa(
+    'pnpm',
+    isTest
+      ? [
+          ...(monorepoProjectDir ? ['-r'] : []),
+          'add',
+          '-D',
+          '--prefer-offline',
+          '../packages/base',
+          ...toolchains.map((t) => t.replace(`${name}-`, '../packages/')),
+        ]
+      : [
+          ...(monorepoProjectDir ? ['-r'] : []),
+          'update',
+          '--prefer-offline',
+          `${name}@^${version}`,
+          toolchains.map((t) => `${t}@^${version}`),
+        ]
+  )
+  if (monorepoProjectDir) await execa('pnpm', ['-r', 'run', 'tc', 'migrate'])
+  else await execa('tc', ['migrate'])
 }
 
 exports.description = 'upgrade toolchains and migrate'

package/util/execa.cjs

@@ -1,7 +1,6 @@
 const Path = require('path')
 const execa = require('execa')
 const chalk = require('chalk')
-const { projectDir, toolchainPackages } = require('./findUps.cjs')
 
 function formatArg(arg) {
   if (/^[-_a-z0-9=./]+$/i.test(arg)) return arg
@@ -15,6 +14,13 @@ function extractCommand(command) {
 }
 
 function getExecaArgs(command, args, options, ...rest) {
+  let projectDir, toolchainPackages
+  try {
+    ;({ projectDir, toolchainPackages } = require('./findUps.cjs'))
+  } catch (error) {
+    projectDir = process.cwd()
+    toolchainPackages = []
+  }
   if (args instanceof Object && !Array.isArray(args)) {
     options = args
     args = []

package/util/findUps.cjs

@@ -1,6 +1,7 @@
 const findUp = require('find-up')
 const Path = require('path')
 const fs = require('fs-extra')
+const glob = require('glob')
 const merge = require('./merge.cjs')
 const once = require('./once.cjs')
 const { name } = require('../package.json')
@@ -59,6 +60,16 @@ exports.monorepoPackageJson = monorepoPackageJsonFile
   ? fs.readJsonSync(monorepoPackageJsonFile)
   : undefined
 
+exports.monorepoSubpackageJsonFiles = pnpmWorkspace
+  ? [
+      ...new Set(
+        pnpmWorkspace.packages.flatMap((p) =>
+          glob.sync(Path.join(p, 'package.json'), { cwd: monorepoProjectDir })
+        )
+      ),
+    ].map((f) => Path.resolve(monorepoProjectDir, f))
+  : undefined
+
 const findGitDir = once(function findGitDir(cwd = process.cwd()) {
   let stopAt = Path.dirname(monorepoProjectDir || projectDir)
   if (stopAt === '/') stopAt = undefined

package/util/getPlugins.cjs

@@ -1,8 +1,8 @@
 const Path = require('path')
 const sortPlugins = require('./sortPlugins.cjs')
-const { projectDir, toolchainPackages } = require('./findUps.cjs')
 
 function getPlugins(name) {
+  const { projectDir, toolchainPackages } = require('./findUps.cjs')
   const plugins = {}
   for (const pkg of toolchainPackages) {
     let path

package/util/parseRepositoryUrl.cjs

@@ -0,0 +1,11 @@
+const { parse: parseUrl } = require('url')
+
+const repoRegExp = new RegExp('^/(.+?)/([^/.]+)')
+
+module.exports = function parseRepositoryUrl(url) {
+  const parsed = parseUrl(url)
+  const match = repoRegExp.exec(parsed.path || '')
+  if (!match) throw new Error(`unsupported source repository url: ${url}`)
+  const [organization, repo] = match.slice(1)
+  return { ...parsed, organization, repo }
+}