normalize-options.ts

import globby, { hasMagic } from 'globby'
import type { ReleaseType } from './release-type'
import { isReleaseType } from './release-type'
import type { VersionBumpOptions } from './types/version-bump-options'

interface Interface {
  input?: NodeJS.ReadableStream | NodeJS.ReadStream | false
  output?: NodeJS.WritableStream | NodeJS.WriteStream | false
  [key: string]: unknown
}

/**
 * A specific version release.
 */
export interface VersionRelease {
  type: 'version'
  version: string
}

/**
 * Prompt the user for the release number.
 */
export interface PromptRelease {
  type: 'prompt'
  preid: string
}

/**
 * A bump release, relative to the current version number.
 */
export interface BumpRelease {
  type: ReleaseType
  preid: string
}

/**
 * One of the possible Release types.
 */
export type Release = VersionRelease | PromptRelease | BumpRelease

/**
 * Normalized and sanitized options
 */
export interface NormalizedOptions {
  release: Release
  commit?: {
    message: string
    noVerify: boolean
    all: boolean
  }
  tag?: {
    name: string
  }
  push: boolean
  files: string[]
  cwd: string
  interface: Interface
  ignoreScripts: boolean
  execute?: string
}

/**
 * Converts raw VersionBumpOptions to a normalized and sanitized Options object.
 */
export async function normalizeOptions(raw: VersionBumpOptions): Promise<NormalizedOptions> {
  // Set the simple properties first
  const preid = typeof raw.preid === 'string' ? raw.preid : 'beta'
  const push = Boolean(raw.push)
  const all = Boolean(raw.all)
  const noVerify = Boolean(raw.noVerify)
  const cwd = raw.cwd || process.cwd()
  const ignoreScripts = Boolean(raw.ignoreScripts)
  const execute = raw.execute

  let release: Release
  if (!raw.release || raw.release === 'prompt')
    release = { type: 'prompt', preid }

  else if (isReleaseType(raw.release))
    release = { type: raw.release, preid }

  else
    release = { type: 'version', version: raw.release }

  let tag
  if (typeof raw.tag === 'string')
    tag = { name: raw.tag }

  else if (raw.tag)
    tag = { name: 'v' }

  // NOTE: This must come AFTER `tag` and `push`, because it relies on them
  let commit
  if (typeof raw.commit === 'string')
    commit = { all, noVerify, message: raw.commit }

  else if (raw.commit || tag || push)
    commit = { all, noVerify, message: 'chore: release v' }

  let files
  if (Array.isArray(raw.files) && raw.files.length > 0) {
    files = await strictGlobMatches(raw.files, { cwd })
  }
  else {
    // Try to find these files by default.
    // If they don't exist, then they will NOT be included in the `files` array.
    files = await globby(['package.json', 'package-lock.json'], { cwd })
  }

  let ui: Interface
  if (raw.interface === false) {
    ui = { input: false, outut: false }
  }
  else if (raw.interface === true || !raw.interface) {
    ui = { input: process.stdin, output: process.stdout }
  }
  else {
    // eslint-disable-next-line prefer-const
    let { input, output, ...other } = raw.interface

    if (input === true || (input !== false && !input))
      input = process.stdin

    if (output === true || (output !== false && !output))
      output = process.stdout

    ui = { input, output, ...other }
  }

  if (release.type === 'prompt' && !(ui.input && ui.output))
    throw new Error('Cannot prompt for the version number because input or output has been disabled.')

  return { release, commit, tag, push, files, cwd, interface: ui, ignoreScripts, execute }
}

/**
 * Returns all files that match the given glob patterns.
 * An error is thrown if any pattern matches zero files.
 */
async function strictGlobMatches(files: string[], options: object): Promise<string[]> {
  // Match all glob patterns simultaneously
  const matches = await Promise.all(files.map(file => strictGlobMatch(file, options)))

  // Get all the unique files
  const matchedFiles = new Set<string>()
  for (const match of matches) {
    for (const file of match)
      matchedFiles.add(file)
  }

  return [...matchedFiles]
}

/**
 * Returns all files that match the given glob pattern.
 * An error is thrown if the pattern matches zero files.
 */
async function strictGlobMatch(file: string, options: object): Promise<string[]> {
  const matches = await globby(file, options)

  if (matches.length === 0) {
    if (hasMagic(file))
      throw new Error(`Could not find any files matching "${file}".`)

    else
      throw new Error(`Could not find file: ${file}.`)
  }

  // Return files in a predictable order
  return matches.sort()
}