juisy 2.0.0-beta.0

package/bin/cli/cmds/release.js

@@ -0,0 +1,231 @@
+const path = require('path')
+const semver = require('semver')
+const juisy = require('../../../src')
+
+const {
+  $style,
+  log,
+  step,
+  substep,
+  run,
+  error,
+  wait,
+  confirm,
+  prompts
+} = juisy.utils
+
+const rootDir = path.resolve(__dirname, '../../../')
+
+// Get package.json content
+const packageJson = require(path.resolve(rootDir, './package.json'))
+const updateVersion = require('../lib/version/update-version')
+
+// Exports command object
+module.exports = {
+  private: true,
+  /**
+   * Command syntax
+   */
+  command: 'release',
+  /**
+   * Aliases
+   */
+  aliases: [],
+  /**
+   * Command description
+   */
+  describe: 'Make a release',
+  /**
+   * Builder
+   * @param {Object} yargs
+   * @return {Object}
+   */
+  builder: function (yargs) {
+    return yargs.option('p', {
+      alias: 'preid',
+      type: 'string',
+      describe: 'Pre-release id',
+      requiresArg: true
+    })
+  },
+  /**
+   * Handler
+   * @param {Object} argv - The argv
+   * @return {void}
+   */
+  handler: async function (argv) {
+    let targetVersion
+    const currentVersion = packageJson.version
+    const packageName = packageJson.name
+    const preId = argv.preid || (semver.prerelease(currentVersion) && semver.prerelease(currentVersion)[0])
+    const inc = i => semver.inc(currentVersion, i, preId)
+    const versionIncrements = [
+      'patch',
+      'minor',
+      'major',
+      ...(preId ? [ 'prepatch', 'preminor', 'premajor', 'prerelease' ] : [])
+    ]
+
+    /**
+     * First, check if local repository is clean
+     */
+    step('Checking changes to commit')
+    const { stdout } = await run('git', [ 'diff' ], { stdio: 'pipe', cwd: rootDir })
+    if (stdout) {
+      error('Please commit your changes before creating a new release!', new Error('There are changes to commit'))
+    }
+    substep($style.green('✔ Local repository is clean'), { last: true })
+    log() // Blank line
+
+    /**
+     * Release prompt
+     */
+    step('Setup')
+    const { release } = await prompts([
+      {
+        type: 'select',
+        name: 'release',
+        message: 'Release type:',
+        choices: versionIncrements.map(i => ({ title: `${i} (${inc(i)})`, value: inc(i) })).concat([ { title: 'custom', value: 'custom' } ])
+      }
+    ])
+    // If custom release
+    if (release === 'custom') {
+      const { version: customVersion } = await prompts([
+        {
+          type: 'text',
+          name: 'version',
+          message: 'New custom version:',
+          initial: currentVersion,
+          validate: value => Boolean(semver.valid(value))
+        }
+      ])
+      targetVersion = customVersion
+    } else {
+      targetVersion = release
+    }
+
+    /**
+     * Demand confirmation
+     */
+    await confirm({ message: `Releasing v${targetVersion}. Confirm?` })
+    log() // Blank line
+
+    /**
+     * Run tests
+     */
+    // step(`Running tests`)
+    // ... here run tests
+
+    /**
+     * Update version in necessary files
+     */
+    await updateVersion(targetVersion)
+    log() // Blank line
+
+    /**
+     * Generate docs
+     */
+    step('Generate docs')
+    await wait('API docs', async () => {
+      await run('node', [ './bin/cli', 'docs', 'generate:api' ], { stdio: 'pipe', cwd: rootDir })
+    })
+    substep($style.green('✔ API docs successfuly generated'))
+    await wait('CLI docs', async () => {
+      await run('node', [ './bin/cli', 'docs', 'generate:cli' ], { stdio: 'pipe', cwd: rootDir })
+    })
+    substep($style.green('✔ CLI docs successfuly generated'))
+    await wait('README', async () => {
+      await run('node', [ './bin/cli', 'docs', 'generate:readme' ], { stdio: 'pipe', cwd: rootDir })
+    })
+    substep($style.green('✔ README successfuly generated'), { last: true })
+    // await wait('Linting', async () => {
+    //   await run('node', [ './bin/cli', 'docs', 'lint', '-c', './docs/.markdownlint-cli2.cjs' ], { stdio: 'pipe', cwd: rootDir })
+    // })
+    log() // Blank line
+
+    /**
+     * Generate changelog file
+     */
+    step('Generating changelog')
+    await wait('Generating', async () => {
+      await run('node', [ './bin/cli', 'changelog' ], { stdio: 'pipe', cwd: rootDir })
+    })
+    substep($style.green('✔ Success'), { last: true })
+    log() // Blank line
+
+    /**
+     * Confirm changes to commit
+     */
+    step('Confirm changes to commit')
+    substep($style.yellow('↓ The following changes will be committed:'))
+    await run('git', [ 'status', '-s' ], { stdio: 'inherit', cwd: rootDir })
+    substep($style.yellow('- The following tag will be created: ') + `v${targetVersion}`, { last: true })
+
+    /**
+     * Demand confirmation
+     */
+    await confirm()
+    log() // Blank line
+
+    /**
+     * Publish package
+     */
+    step(`Publishing ${packageName}`)
+    const releaseTag = targetVersion.includes('alpha')
+      ? 'alpha'
+      : targetVersion.includes('beta')
+        ? 'beta'
+        : targetVersion.includes('rc')
+          ? 'rc'
+          : null
+    let alreadyPublished = false
+    await wait('Publishing', async () => {
+      try {
+        await run('npm', [ 'publish', ...(releaseTag ? [ '--tag', releaseTag ] : []) ], { stdio: 'pipe', cwd: rootDir })
+      } catch (e) {
+        if (e.stderr.match(/previously published/)) {
+          alreadyPublished = true
+        } else {
+          error('Unknown error during publishing', e)
+        }
+      }
+    })
+    substep(
+      alreadyPublished
+        ? $style.yellow(`Skipping already published: ${packageName}`)
+        : $style.green('✔ Success'),
+      { last: true }
+    )
+    log() // Blank line
+
+    /**
+     * Push to git
+     */
+    step('Pushing changes')
+    await wait('Committing', async () => {
+      try {
+        await run('git', [ 'add', '.' ], { stdio: 'pipe', cwd: rootDir })
+        await run('git', [ 'commit', '-m', `chore(release): v${targetVersion}` ], { stdio: 'pipe', cwd: rootDir })
+      } catch (e) {
+        error('Unable to commit', e)
+      }
+    })
+    substep($style.green('✔ Committed'))
+    await wait('Creating tag', async () => {
+      try {
+        await run('git', [ 'tag', '-a', `v${targetVersion}`, '-m', `v${targetVersion}` ], { stdio: 'pipe', cwd: rootDir })
+      } catch (e) {
+        error('Unable to create tag', e)
+      }
+    })
+    substep($style.green('✔ Tagged'))
+    log() // blank line
+
+    log($style.green(`✔ Release v${targetVersion} successfuly created`))
+    log()
+
+    log($style.yellow('IMPORTANT: You should now run ') + 'git push origin --follow-tags')
+    log()
+  }
+}

package/bin/cli/cmds/squeeze.js

@@ -0,0 +1,269 @@
+import path, { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { getPackageInfo, eject } from '#juisy'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const isDef = value => value !== undefined
+
+/** @type {import('#juisy/cli').Command} */
+export default new CLI.Command({
+  command: 'squeeze',
+  describe: 'Initialize project folder',
+  builder (yargs) {
+    yargs.option('f', {
+      alias: 'force',
+      type: 'boolean',
+      default: false,
+      describe: 'Overwrites existing files / scripts / ...'
+    })
+    return yargs
+  },
+  async handler (argv) {
+    const {
+      rootDir: targetProjectRootDir, // rootDir is parent project
+      prompts,
+      run
+    } = CLI.InterfaceUtils
+    const {
+      $style,
+      log,
+      step,
+      substep
+    } = CLI.OutputUtils
+
+    const templateDir = 'template'
+    const getTemplatePath = target => path.resolve(__dirname, '../../../', templateDir, target)
+
+    /**
+     * Eject files from template
+     */
+    step('Copying files')
+
+    await eject('**/*', {
+      force: argv.force,
+      logLevel: 'warn'
+    })
+
+    substep($style.green(`✔ Successfuly copied`), { last: true })
+    log() // Blank line
+
+    // substep($style.yellow('Target directory "bin" already exists. Skipped... Use --force option to overwrite'), { last: true })
+
+    /**
+     * Update package.json file
+     */
+    // const scripts = {
+    //   'docs:api':              'node ./bin/cli docs generate -c ./docs/docs.config.js',
+    //   'docs:readme':           'node ./bin/cli docs generate:readme',
+    //   'docs:lint':             'node ./bin/cli docs lint',
+    //   'docs:lint:fix':         'npm run docs:lint -- --fix',
+    //   'docs':                  'npm run docs:readme && npm run docs:api && npm run docs:lint',
+    //   'lint':                  'npx eslint . --ext .js',
+    //   'lint:fix':              'npm run lint -- --fix',
+    //   'lint:markdown':         'npm run docs:lint',
+    //   'lint:markdown:fix':     'npm run docs:lint:fix',
+    //   'release':               'node ./bin/cli release',
+    //   'changelog':             'node ./bin/cli changelog',
+    //   'git-hooks:reset':       'node ./bin/cli git-hooks reset',
+    //   'git-hooks:sync':        'node ./bin/cli git-hooks sync',
+    //   'test':                  'node ./bin/cli test',
+    //   'postinstall':           'npm run git-hooks:sync'
+    // }
+
+    const targetCliCommand = 'node ./bin/cli'
+
+    step('Adding scripts to package.json')
+    const packageJson = getPackageInfo()
+    packageJson.scripts = packageJson.scripts || {}
+
+    // "docs:api": "node ./bin/cli docs generate:api"
+    let setScript = isDef(packageJson.scripts['docs:api'])
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'docs:api', `${targetCliCommand} docs generate:api` ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "docs:api" successfuly added'))
+    } else {
+      substep($style.yellow('Script "docs:api" already set. Use --force option to overwrite'))
+    }
+
+    // "docs:readme": "node ./bin/cli docs generate:readme -c ./docs/readme/config.js"
+    setScript = isDef(packageJson.scripts['docs:readme'])
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [
+        'set-script',
+        'docs:readme',
+        `${targetCliCommand} docs generate:readme -c ./docs/readme/config.js`
+      ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "docs:readme" successfuly added'))
+    } else {
+      substep($style.yellow('Script "docs:readme" already set. Use --force option to overwrite'))
+    }
+
+    // "docs": "npm run docs:readme && npm run docs:api"
+    setScript = isDef(packageJson.scripts.docs)
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'docs', 'npm run docs:readme && npm run docs:api' ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "docs" successfuly added'))
+    } else {
+      substep($style.yellow('Script "docs" already set. Use --force option to overwrite'))
+    }
+
+    // "release": "node ./bin/cli release"
+    setScript = isDef(packageJson.scripts.release)
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'release', `${targetCliCommand} release` ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "release" successfuly added'))
+    } else {
+      substep($style.yellow('Script "release" already set. Use --force option to overwrite'))
+    }
+
+    // "changelog": "node ./bin/cli changelog"
+    setScript = isDef(packageJson.scripts.changelog)
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'changelog', `${targetCliCommand} changelog` ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "changelog" successfuly added'))
+    } else {
+      substep($style.yellow('Script "changelog" already set. Use --force option to overwrite'))
+    }
+
+    // "git-hooks:reset": "node ./bin/cli git-hooks reset"
+    setScript = isDef(packageJson.scripts['git-hooks:reset'])
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'git-hooks:reset', `${targetCliCommand} git-hooks reset` ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "git-hooks:reset" successfuly added'))
+    } else {
+      substep($style.yellow('Script "git-hooks:reset" already set. Use --force option to overwrite'))
+    }
+
+    // "git-hooks:sync": "node ./bin/cli git-hooks sync"
+    setScript = isDef(packageJson.scripts['git-hooks:sync'])
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'git-hooks:sync', `${targetCliCommand} git-hooks sync` ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "git-hooks:sync" successfuly added'))
+    } else {
+      substep($style.yellow('Script "git-hooks:sync" already set. Use --force option to overwrite'))
+    }
+
+    // "postinstall": "npm run git-hooks:sync"
+    setScript = isDef(packageJson.scripts.postinstall)
+      ? argv.force
+      : true
+    if (setScript) {
+      await run('npm', [ 'set-script', 'postinstall', 'npm run git-hooks:sync' ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Script "postinstall" successfuly added'))
+    } else {
+      substep($style.yellow('Script "postinstall" already set. Use --force option to overwrite'))
+    }
+    substep($style.green('✔ package.json updated'), { last: true })
+    log() // Blank line
+
+    // Adding repository info
+    step('Adding repository config to package.json')
+    // set repository config
+    const setRepository = isDef(packageJson.repository)
+      ? argv.force
+      : true
+    if (setRepository) {
+      const repositoryConfig = {
+        type: 'git',
+        url: 'https://gitlab.com/hperchec/juisy'
+      }
+      await run('npm', [
+        'pkg',
+        'set',
+        `repository=${JSON.stringify(repositoryConfig)}`,
+        '--json'
+      ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Repository config successfuly added'), { last: true })
+    } else {
+      substep($style.yellow('Repository config already set. Use --force option to overwrite'), { last: true })
+    }
+    log() // Blank line
+
+    // Adding issues URL info
+    step('Adding issues/bugs config to package.json')
+    // set bugs config
+    const setBugs = isDef(packageJson.bugs)
+      ? argv.force
+      : true
+    if (setBugs) {
+      const bugsConfig = {
+        url: 'https://gitlab.com/hperchec/juisy/issues'
+      }
+      await run('npm', [
+        'pkg',
+        'set',
+        `bugs=${JSON.stringify(bugsConfig)}`,
+        '--json'
+      ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Issues/bugs config successfuly added'), { last: true })
+    } else {
+      substep($style.yellow('Issues/bugs config already set. Use --force option to overwrite'), { last: true })
+    }
+    log() // Blank line
+
+    // Adding git hooks
+    step('Adding git hooks config to package.json')
+    // set simple-git-hook config
+    const setSimpleGitHook = isDef(packageJson['simple-git-hooks'])
+      ? argv.force
+      : true
+    if (setSimpleGitHook) {
+      const simpleGitHookConfig = {
+        'pre-commit': 'node ./bin/scripts/pre-commit.js',
+        'commit-msg': 'node ./bin/scripts/commit-msg.js ${1}'
+      }
+      await run('npm', [
+        'pkg',
+        'set',
+        `simple-git-hooks=${JSON.stringify(simpleGitHookConfig)}`,
+        '--json'
+      ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ Git hooks successfuly added'), { last: true })
+    } else {
+      substep($style.yellow('Git hooks already set. Use --force option to overwrite'), { last: true })
+    }
+    log() // Blank line
+
+    // Adding lint-staged configured
+    step('Adding lint-staged config to package.json')
+    // set lint-staged config
+    const setLintStaged = isDef(packageJson['lint-staged'])
+      ? argv.force
+      : true
+    if (setLintStaged) {
+      const lintStagedConfig = {
+        '*.js': [
+          'eslint --fix',
+          'git add'
+        ]
+      }
+      await run('npm', [
+        'pkg',
+        'set',
+        `lint-staged=${JSON.stringify(lintStagedConfig)}`,
+        '--json'
+      ], { stdio: 'pipe', cwd: targetProjectRootDir })
+      substep($style.green('✔ lint-staged successfuly configured'), { last: true })
+    } else {
+      substep($style.yellow('lint-staged already configured. Use --force option to overwrite'), { last: true })
+    }
+    log() // Blank line
+  }
+})

package/bin/cli/cmds/test.js

@@ -0,0 +1,33 @@
+/** @type {import('#juisy/cli').Command} */
+export default new CLI.Command({
+  command: 'test',
+  describe: 'Run project tests',
+  meta: {
+    private: true
+  },
+  builder (cli) {
+    cli.option('watch', {
+      alias: 'w',
+      type: 'boolean',
+      default: false,
+      describe: 'Run vitest in watch mode'
+    })
+    cli.option('ui', {
+      type: 'boolean',
+      default: false,
+      describe: 'Launch vitest UI'
+    })
+    return cli
+  },
+  async handler (args) {
+    const watchMode = args.watch || args.ui
+    const { run } = CLI.InterfaceUtils
+    /**
+     * Run tests
+     */
+    await run('vitest', [
+      ...(watchMode ? [] : [ 'run' ]),
+      ...(args.ui ? [ '--ui' ] : [])
+    ], { stdio: 'inherit' })
+  }
+})

package/bin/cli/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+'use strict'
+
+import cli from './cli.js'
+
+const argv = CLI.helpers.hideBin(process.argv)
+
+cli().parse(argv)

package/bin/cli/lib/docs/generate-api-doc.js

@@ -0,0 +1,78 @@
+// import fs from 'fs-extra'
+// import jsdoc2md from 'jsdoc-to-markdown'
+import path from 'path'
+import { InterfaceUtils, OutputUtils } from '#juisy/cli'
+
+// utils
+const { rootDir } = InterfaceUtils
+const {
+  $style,
+  log,
+  step,
+  substep
+} = OutputUtils
+
+// Default config
+const defaultConfig = {
+  outputDir: 'documentation',
+  jsdoc: {
+    configPath: undefined
+  },
+  jsdoc2md: {
+    partial: []
+  }
+}
+
+/**
+ * Generate API doc function
+ * @param {object} [options = {}] - The options object
+ * @returns {void}
+ */
+export default async function generateApiDoc (options = {}) {
+  // Process options
+  options = merge(defaultConfig, options)
+
+  const docs = {
+    API: {
+      sourcePath: path.resolve(rootDir, './src/index.js'),
+      destPath: path.resolve(rootDir, './documentation/api.md')
+    },
+    Utils: {
+      sourcePath: path.resolve(rootDir, './src/utils/index.js'),
+      destPath: path.resolve(rootDir, './documentation/utils.md')
+    }
+  }
+
+  /**
+   * Generate doc
+   */
+  step('Generate doc')
+
+  // // Loop on docs
+  // for (const name in docs) {
+  //   const sourcePath = docs[name].sourcePath
+  //   const destPath = docs[name].destPath
+
+  //   let genResult
+  //   await wait(`Generating "${name}"`, async () => {
+  //     genResult = await jsdoc2md.render({
+  //       'no-cache': Boolean(options.jsdoc.configPath),
+  //       files: sourcePath,
+  //       template: `# ${name} documentation\n\n{{>main}}`,
+  //       partial: options.jsdoc2md.partial,
+  //       configure: options.jsdoc.configPath
+  //     })
+  //   })
+  //   // f*cking windows compat:
+  //   // jsdoc2md will generate CR (\r) character for @example blocks content line endings
+  //   genResult = genResult.replace(/\r(\n)?/g, '\n')
+  //   // Write output
+  //   await wait(`Writing file "${path.basename(destPath)}"`, async () => {
+  //     await fs.writeFile(destPath, genResult, { encoding: 'utf8' })
+  //   })
+  //   substep(`File "${path.basename(destPath)}" successfuly generated`)
+  // }
+
+  substep($style.green('✔ Success'), { last: true })
+  log() // Blank line
+}

package/bin/cli/lib/version/update-version.js

@@ -0,0 +1,52 @@
+const fs = require('fs')
+const path = require('path')
+const juisy = require('../../../../src')
+
+const {
+  $style,
+  error,
+  step,
+  substep,
+  run,
+  wait
+} = juisy.utils
+
+const rootDir = path.resolve(__dirname, '../../../../')
+
+// File paths
+const filePaths = {
+  packageJson: path.resolve(rootDir, './package.json')
+}
+// Get package.json content
+const packageJson = require(filePaths.packageJson)
+
+/**
+ * Update version in necessary files
+ * @param {string} version - The version
+ * @return {void}
+ */
+module.exports = async function updateVersion (version) {
+  // Update version for each file
+  packageJson.version = version
+
+  /**
+   * Update files
+   */
+  step('Updating version in necessary files')
+  // Update package.json
+  try {
+    fs.writeFileSync(filePaths.packageJson, JSON.stringify(packageJson, null, 4), 'utf8')
+  } catch (e) {
+    error('Unable to update package.json file', e)
+  }
+  substep($style.green('✔ package.json successfuly updated'))
+  // Updating package-lock
+  await wait('Updating package-lock.json', async () => {
+    try {
+      await run('npm', [ 'install', '--prefer-offline' ], { stdio: 'pipe', cwd: rootDir })
+    } catch (e) {
+      error('Unable to update package-lock.json file', e)
+    }
+  })
+  substep($style.green('✔ package-lock.json successfuly updated'), { last: true })
+}