@jcoreio/toolchain 1.0.0-beta.1

package/scripts/preinstall.cjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+const fs = require('../util/projectFs.cjs')
+
+async function preinstall(args = []) {
+  const preinstallUpdateProjectPackageJson = require('./preinstall/preinstallUpdateProjectPackageJson.cjs')
+
+  await Promise.all(
+    require('./preinstall/preinstallRemoveFiles.cjs').map(async (file) => {
+      const exists = await fs.pathExists(file)
+      if (exists) {
+        await fs.remove(file)
+        // eslint-disable-next-line no-console
+        console.error('removed', file)
+      }
+    })
+  )
+
+  await preinstallUpdateProjectPackageJson()
+}
+
+exports.description =
+  'run this script before installing toolchains in a project'
+exports.run = preinstall
+
+if (require.main === module) {
+  preinstall().then(
+    () => process.exit(0),
+    (error) => {
+      // eslint-disable-next-line no-console
+      console.error(error.stack)
+      process.exit(error.exitCode != null ? error.exitCode : 1)
+    }
+  )
+}

package/scripts/prepublish.cjs

@@ -0,0 +1,11 @@
+const check = require('./check.cjs')
+const coverage = require('./coverage.cjs')
+const build = require('./build.cjs')
+
+exports.run = async function (args = []) {
+  await check.run()
+  await coverage.run()
+  await build.run()
+}
+
+exports.description = 'run check, coverage, and build'

package/scripts/runEslint.cjs

@@ -0,0 +1,34 @@
+const fs = require('../util/projectFs.cjs')
+const execa = require('../util/execa.cjs')
+const getPluginsArraySync = require('../util/getPluginsArraySync.cjs')
+
+async function eslintArgs() {
+  return [
+    ...((await fs.pathExists('.eslintignore'))
+      ? ['--ignore-path', '.eslintignore']
+      : (await fs.pathExists('.gitignore'))
+      ? ['--ignore-path', '.gitignore']
+      : []),
+    '--ignore-pattern',
+    'flow-typed/',
+    '--ext',
+    getPluginsArraySync('lintExtensions').join(','),
+  ]
+}
+
+async function runEslint(args = []) {
+  await execa('eslint', [...args, ...(await eslintArgs())])
+}
+exports.runEslint = runEslint
+
+async function eslintCheck(args = []) {
+  if (args.length === 0) args = ['.']
+  await runEslint(args)
+}
+exports.eslintCheck = eslintCheck
+
+async function eslintFix(args = []) {
+  if (args.length === 0) args = ['.']
+  await runEslint(['--fix', ...args])
+}
+exports.eslintFix = eslintFix

package/scripts/runPrettier.cjs

@@ -0,0 +1,27 @@
+const fs = require('../util/projectFs.cjs')
+const execa = require('../util/execa.cjs')
+
+async function prettierArgs() {
+  return (await fs.pathExists('.prettierignore'))
+    ? ['--ignore-path', '.prettierignore']
+    : (await fs.pathExists('.gitignore'))
+    ? ['--ignore-path', '.gitignore']
+    : []
+}
+
+async function runPrettier(args = []) {
+  await execa('prettier', [...(await prettierArgs()), ...args])
+}
+exports.runPrettier = runPrettier
+
+async function prettierCheck(args = []) {
+  if (args.length === 0) args = ['.', '!pnpm-lock.yaml']
+  await runPrettier(['-c', ...args])
+}
+exports.prettierCheck = prettierCheck
+
+async function prettierFormat(args = []) {
+  if (args.length === 0) args = ['.', '!pnpm-lock.yaml']
+  await runPrettier(['--write', ...args])
+}
+exports.prettierFormat = prettierFormat

package/scripts/test.cjs

@@ -0,0 +1,12 @@
+const getPlugins = require('../util/getPlugins.cjs')
+const getPluginsAsyncFunction = require('../util/getPluginsAsyncFunction.cjs')
+
+exports.run = async function (args = []) {
+  if (!getPlugins('test').length) {
+    throw new Error(
+      'missing test toolchain, install @jcoreio/toolchain-mocha (there may be alternatives in the future)'
+    )
+  }
+  await getPluginsAsyncFunction('test')(args)
+}
+exports.description = 'run tests'

package/scripts/toolchain.cjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+const { name, version } = require('../package.json')
+const chalk = require('chalk')
+
+const scripts = {
+  bootstrap: require('./bootstrap.cjs'),
+  build: require('./build.cjs'),
+  check: require('./check.cjs'),
+  clean: require('./clean.cjs'),
+  coverage: require('./coverage.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'),
+  test: require('./test.cjs'),
+  version: {
+    description: `print version of ${name}`,
+    run: () => {
+      // eslint-disable-next-line no-console
+      console.log(`${name}@${version}`)
+    },
+  },
+}
+
+exports.scripts = scripts
+
+async function toolchain(command, args) {
+  if (!command) {
+    /* eslint-disable no-console */
+    console.error('Usage: toolchain <command> <arguments...>\n')
+    console.error('Available commands:')
+    for (const script of Object.keys(scripts).sort()) {
+      console.error(
+        chalk`  {bold ${script.padEnd(20)}}${scripts[script].description}`
+      )
+    }
+    /* eslint-enable no-console */
+    process.exit(1)
+  }
+  const script = scripts[command]
+  if (!script) {
+    console.error('Unknown command:', command) // eslint-disable-line no-console
+    process.exit(1)
+  }
+
+  if (script !== scripts.version) {
+    console.error(chalk`{bold ${name}@${version}}`) // eslint-disable-line no-console
+  }
+
+  try {
+    await script.run(args)
+  } catch (error) {
+    const { exitCode } = error
+    if (typeof exitCode === 'number' && exitCode !== 0) {
+      console.error(error.message) // eslint-disable-line no-console
+    } else {
+      console.error(error.stack) // eslint-disable-line no-console
+    }
+    throw error
+  }
+}
+exports.toolchain = toolchain
+
+if (require.main === module) {
+  toolchain(process.argv[2], process.argv.slice(3)).then(
+    () => {
+      process.exit(0)
+    },
+    (error) => {
+      const { exitCode } = error
+      if (typeof exitCode === 'number' && exitCode !== 0) {
+        process.exit(exitCode)
+      } else {
+        process.exit(1)
+      }
+    }
+  )
+}

package/util/ChdirFs.cjs

@@ -0,0 +1,50 @@
+const fs = require('fs-extra')
+const { resolve } = require('path')
+
+function ChdirFs(cwd) {
+  return {
+    copy: (src, dest, ...args) =>
+      fs.copy(resolve(cwd, src), resolve(cwd, dest), ...args),
+    copySync: (src, dest, ...args) =>
+      fs.copySync(resolve(cwd, src), resolve(cwd, dest), ...args),
+    lstat: (path, ...args) => fs.lstat(resolve(cwd, path), ...args),
+    stat: (path, ...args) => fs.stat(resolve(cwd, path), ...args),
+    lstatSync: (path, ...args) => fs.lstatSync(resolve(cwd, path), ...args),
+    statSync: (path, ...args) => fs.statSync(resolve(cwd, path), ...args),
+    pathExists: (path, ...args) => fs.pathExists(resolve(cwd, path), ...args),
+    pathExistsSync: (path, ...args) =>
+      fs.pathExistsSync(resolve(cwd, path), ...args),
+    ensureFile: (path, ...args) => fs.ensureFile(resolve(cwd, path), ...args),
+    ensureFileSync: (path, ...args) =>
+      fs.ensureFileSync(resolve(cwd, path), ...args),
+    move: (src, dest, ...args) =>
+      fs.move(resolve(cwd, src), resolve(cwd, dest), ...args),
+    moveSync: (src, dest, ...args) =>
+      fs.moveSync(resolve(cwd, src), resolve(cwd, dest), ...args),
+    readFile: (path, ...args) => fs.readFile(resolve(cwd, path), ...args),
+    readFileSync: (path, ...args) =>
+      fs.readFileSync(resolve(cwd, path), ...args),
+    readJson: (path, ...args) => fs.readJson(resolve(cwd, path), ...args),
+    readJsonSync: (path, ...args) =>
+      fs.readJsonSync(resolve(cwd, path), ...args),
+    writeFile: (path, ...args) => fs.writeFile(resolve(cwd, path), ...args),
+    writeFileSync: (path, ...args) =>
+      fs.writeFileSync(resolve(cwd, path), ...args),
+    writeJson: (path, ...args) => fs.writeJson(resolve(cwd, path), ...args),
+    writeJsonSync: (path, ...args) =>
+      fs.writeJsonSync(resolve(cwd, path), ...args),
+    mkdirs: (path, ...args) => fs.mkdirs(resolve(cwd, path), ...args),
+    mkdirsSync: (path, ...args) => fs.mkdirsSync(resolve(cwd, path), ...args),
+    remove: (path, ...args) => fs.remove(resolve(cwd, path), ...args),
+    removeSync: (path, ...args) => fs.removeSync(resolve(cwd, path), ...args),
+    readdir: (path, ...args) => fs.readdir(resolve(cwd, path), ...args),
+    readdirSync: (path, ...args) => fs.readdirSync(resolve(cwd, path), ...args),
+    readlink: (path, ...args) => fs.readlink(resolve(cwd, path), ...args),
+    readlinkSync: (path, ...args) =>
+      fs.readlinkSync(resolve(cwd, path), ...args),
+    realpath: (path, ...args) => fs.realpath(resolve(cwd, path), ...args),
+    realpathSync: (path, ...args) =>
+      fs.realpathSync(resolve(cwd, path), ...args),
+  }
+}
+module.exports = ChdirFs

package/util/execa.cjs

@@ -0,0 +1,72 @@
+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
+  return `'${arg.replace(/'/g, "'\\''")}'`
+}
+
+function extractCommand(command) {
+  command = Path.basename(command).trim()
+  const match = /^\S+/.exec(command)
+  return match ? match[0] : command
+}
+
+module.exports = async function defaultExeca(command, args, options, ...rest) {
+  if (args instanceof Object && !Array.isArray(args)) {
+    options = args
+    args = []
+  } else if (!options) {
+    options = {}
+  }
+
+  // eslint-disable-next-line no-console
+  console.error(
+    chalk`{gray.bold $ ${command}${
+      args ? ' ' + args.map(formatArg).join(' ') : ''
+    }}`
+  )
+
+  const opts = {
+    stdio: 'inherit',
+    cwd: projectDir,
+    ...options,
+    env: {
+      ...process.env,
+      ...options.env,
+      PATH: [
+        Path.join(projectDir, 'node_modules', '.bin'),
+        ...toolchainPackages.map((pkg) =>
+          Path.join(projectDir, 'node_modules', pkg, 'node_modules', '.bin')
+        ),
+        (options.env || process.env).PATH,
+      ].join(Path.delimiter),
+    },
+  }
+
+  const child = execa(command, args, opts, ...rest)
+  child.then(
+    (result) => {
+      // eslint-disable-next-line no-console
+      console.error(
+        chalk`{green ✔} {bold ${extractCommand(command)}} exited with code 0`
+      )
+    },
+    (error) => {
+      const { code, signal } = error
+      if (code) {
+        error.message = chalk`{red ✖} {bold ${extractCommand(
+          command
+        )}} exited with code ${code}`
+      }
+      if (signal) {
+        error.message = chalk`{red ✖} {bold ${extractCommand(
+          command
+        )}} was killed with signal ${signal}`
+      }
+    }
+  )
+  return child
+}

package/util/findUps.cjs

@@ -0,0 +1,44 @@
+const findUp = require('find-up')
+const Path = require('path')
+const fs = require('fs-extra')
+const once = require('./once.cjs')
+const { name } = require('../package.json')
+
+const findGitDir = once(function findGitDir(
+  cwd = process.env.INIT_CWD || process.cwd()
+) {
+  return findUp.sync('.git', { cwd, type: 'directory' })
+})
+exports.findGitDir = findGitDir
+
+let cwd = process.cwd()
+
+const nodeModulesMatch = /\/node_modules(\/|$)/.exec(cwd)
+if (nodeModulesMatch) cwd = cwd.substring(0, nodeModulesMatch.index)
+
+const packageJsonFile = findUp.sync('package.json', { cwd, type: 'file' })
+if (!packageJsonFile) {
+  throw new Error(
+    `failed to find project package.json in a parent directory of ${cwd}`
+  )
+}
+exports.packageJsonFile = packageJsonFile
+const packageJson = (exports.packageJson = fs.readJsonSync(packageJsonFile))
+exports.projectDir = Path.dirname(packageJsonFile)
+
+exports.toolchainPackages = [
+  ...Object.keys(packageJson.dependencies || {}),
+  ...Object.keys(packageJson.devDependencies || {}),
+].filter((dep) => dep.startsWith(name))
+
+let toolchainConfigFile
+try {
+  toolchainConfigFile = require.resolve(
+    Path.join(exports.projectDir, 'toolchain.config.cjs')
+  )
+} catch (error) {
+  // ignore
+}
+exports.toolchainConfig = toolchainConfigFile
+  ? require(toolchainConfigFile)
+  : {}

package/util/getPlugins.cjs

@@ -0,0 +1,21 @@
+const Path = require('path')
+const sortPlugins = require('./sortPlugins.cjs')
+const { projectDir, toolchainPackages } = require('./findUps.cjs')
+
+function getPlugins(name) {
+  const plugins = {}
+  for (const pkg of toolchainPackages) {
+    let path
+    try {
+      path = require.resolve(Path.join(pkg, 'plugins', `${name}.cjs`), {
+        paths: [projectDir],
+      })
+    } catch (error) {
+      continue
+    }
+    plugins[pkg] = require(path)
+  }
+  return sortPlugins(plugins)
+}
+
+module.exports = getPlugins

package/util/getPluginsArraySync.cjs

@@ -0,0 +1,14 @@
+const getPlugins = require('./getPlugins.cjs')
+
+function getPluginsArraySync(name, ...args) {
+  const plugins = getPlugins(name)
+  const result = []
+  for (const plugin of plugins) {
+    const output = plugin(...args)
+    if (Array.isArray(output)) output.forEach((el) => result.push(el))
+    else if (output != null) result.push(output)
+  }
+  return result
+}
+
+module.exports = getPluginsArraySync

package/util/getPluginsAsyncFunction.cjs

@@ -0,0 +1,12 @@
+const getPlugins = require('./getPlugins.cjs')
+
+function getPluginsAsyncFunction(name) {
+  const plugins = getPlugins(name)
+  return async function (...args) {
+    for (const plugin of plugins) {
+      await plugin(...args)
+    }
+  }
+}
+
+module.exports = getPluginsAsyncFunction

package/util/getPluginsObject.cjs

@@ -0,0 +1,12 @@
+const getPlugins = require('./getPlugins.cjs')
+
+async function getPluginsObject(name, ...args) {
+  const plugins = getPlugins(name)
+  const result = {}
+  for (const plugin of plugins) {
+    Object.assign(result, await plugin(...args))
+  }
+  return result
+}
+
+module.exports = getPluginsObject

package/util/glob.cjs

@@ -0,0 +1,6 @@
+const _glob = require('util').promisify(require('glob'))
+const { projectDir } = require('./findUps.cjs')
+
+const glob = (what, options) => _glob(what, { cwd: projectDir, ...options })
+
+module.exports = glob

package/util/hasTSSourcesSync.cjs

@@ -0,0 +1,7 @@
+const fs = require('./projectFs.cjs')
+const once = require('./once.cjs')
+
+module.exports = once(function hasTSSourcesSync() {
+  const files = fs.readdirSync('src')
+  return files.find((f) => /\.tsx?$/.test(f) && !/\.d\.tsx?$/.test(f)) != null
+})

package/util/ini.cjs

@@ -0,0 +1,36 @@
+var REG_GROUP = /^\s*\[(.+?)\]\s*$/
+var REG_ITEM = /^\s*([^#[].*)\s*$/
+
+function parse(string) {
+  const object = {}
+  const lines = string.split('\n')
+  let group
+  let match
+
+  for (const line of lines) {
+    if ((match = line.match(REG_GROUP)))
+      object[match[1]] = group = object[match[1]] || []
+    else if (group && (match = line.match(REG_ITEM))) group.push(match[1])
+  }
+
+  return object
+}
+
+exports.parse = parse
+
+function stringify(ini) {
+  const lines = []
+  for (const key in ini) {
+    if (Object.prototype.hasOwnProperty.call(ini, key)) {
+      const group = ini[key]
+      if (Array.isArray(group)) {
+        lines.push(`[${key}]`)
+        for (const item of group) lines.push(item)
+        lines.push('')
+      }
+    }
+  }
+  return lines.join('\n')
+}
+
+exports.stringify = stringify

package/util/once.cjs

@@ -0,0 +1,6 @@
+module.exports = function once(fn) {
+  let result
+  return function onceified() {
+    return (result || (result = [fn.apply(this, arguments)]))[0]
+  }
+}

package/util/projectFs.cjs

@@ -0,0 +1,4 @@
+const ChdirFs = require('./ChdirFs.cjs')
+const { projectDir } = require('./findUps.cjs')
+
+module.exports = ChdirFs(projectDir)

package/util/sortDeps.cjs

@@ -0,0 +1,21 @@
+function sortedObject(obj) {
+  return Object.fromEntries(
+    Object.keys(obj)
+      .sort()
+      .map((key) => [key, obj[key]])
+  )
+}
+
+function sortDeps(packageJson) {
+  for (const section of [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+  ]) {
+    if (packageJson[section])
+      packageJson[section] = sortedObject(packageJson[section])
+  }
+}
+
+module.exports = sortDeps

package/util/sortPlugins.cjs

@@ -0,0 +1,67 @@
+const toposort = require('toposort')
+
+function asArray(x) {
+  return Array.isArray(x) ? x : x ? [x] : []
+}
+
+function normalizeDef(def) {
+  const plugin = Array.isArray(def) ? def[0] : def
+  const options = Array.isArray(def) ? def[1] : {}
+  return {
+    plugin,
+    before: asArray(options.before),
+    after: asArray(options.after),
+    insteadOf: asArray(options.insteadOf),
+  }
+}
+
+function sortPlugins(defs) {
+  const plugins = new Map()
+  const edges = []
+  const excluded = new Set()
+
+  const makeId = (pkg, i) => JSON.stringify({ pkg, i })
+
+  for (const [pkg, pkgDefs] of Object.entries(defs)) {
+    for (let i = 0; i < pkgDefs.length; i++) {
+      const id = makeId(pkg, i)
+      const def = pkgDefs[i]
+      const { plugin, before, after, insteadOf } = normalizeDef(def)
+      plugins.set(id, plugin)
+
+      if (before.length) {
+        for (const other of before) {
+          if (!defs[other]) continue
+          for (let i = 0; i < defs[other].length; i++) {
+            edges.push([id, makeId(other, i)])
+          }
+        }
+      }
+      if (after.length) {
+        for (const other of after) {
+          if (!defs[other]) continue
+          for (let i = 0; i < defs[other].length; i++) {
+            edges.push([makeId(other, i), id])
+          }
+        }
+      }
+      for (const other of insteadOf) {
+        if (!defs[other]) continue
+        for (let i = 0; i < defs[other].length; i++) {
+          excluded.add(makeId(other, i))
+        }
+      }
+    }
+  }
+  const sorted = toposort(edges)
+  const sortedSet = new Set(sorted)
+  for (const [pkg, pkgDefs] of Object.entries(defs)) {
+    for (let i = 0; i < pkgDefs.length; i++) {
+      const id = makeId(pkg, i)
+      if (!sortedSet.has(id)) sorted.push(id)
+    }
+  }
+  return sorted.filter((id) => !excluded.has(id)).map((id) => plugins.get(id))
+}
+
+module.exports = sortPlugins