add my publish script

Author: stamat

script/publish

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+/**
+ * This script is used to publish a new version of the package.
+ * It can automatically increment the patch version if no version is specified in the package.json and commit the changes.
+ * It can also automatically tag and push the tags.
+ * Using GH CLI, it can also create a release.
+ *
+ * Fucking awesome, right?
+ *
+ * With love, @stamat
+ */
+import readline from 'node:readline'
+import { exec, execFile, spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const argVersion = process.argv[2]
+const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'))
+
+function question(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close()
+      resolve(answer)
+    })
+  })
+}
+
+function isValidVersion(version) {
+  return /^(\d+)\.(\d+)\.(\d+)(?:-([\w-]+(?:\.[\w-]+)*))?(?:\+([\w-]+(?:\.[\w-]+)*))?$/.test(version)
+}
+
+function incrementPatchVersion(version) {
+  // can't auto-bump prerelease/build versions (e.g. 1.2.3-beta.1), ask for manual entry instead
+  if (version.includes('-') || version.includes('+')) return null
+  const parts = version.split('.')
+  const patch = parseInt(parts[2]) + 1
+  return `${parts[0]}.${parts[1]}.${patch}`
+}
+
+function runPromise(child) {
+  // stdout/stderr are null when stdio is inherited (interactive commands)
+  child.stdout?.on('data', (data) => {
+    console.log(data.toString())
+  })
+
+  child.stderr?.on('data', (data) => {
+    console.log(data.toString())
+  })
+
+  return new Promise(function(resolve, reject) {
+    child.addListener('error', reject)
+    child.addListener('exit', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(`Command exited with code ${code}`))
+      }
+    })
+  })
+}
+
+async function run(cmd, exitOnError = true) {
+  console.log(cmd)
+  try {
+    await runPromise(exec(cmd))
+  } catch (e) {
+    console.error(e.message)
+    if (exitOnError) process.exit(1)
+  }
+}
+
+// like run(), but inherits stdio so interactive prompts (npm OTP) reach the terminal
+async function runInteractive(cmd, args, exitOnError = true) {
+  console.log([cmd, ...args].join(' '))
+  try {
+    await runPromise(spawn(cmd, args, { stdio: 'inherit', shell: true }))
+  } catch (e) {
+    console.error(e.message)
+    if (exitOnError) process.exit(1)
+  }
+}
+
+// like run(), but takes an args array so user input never touches the shell
+async function runFile(cmd, args, exitOnError = true) {
+  console.log([cmd, ...args].join(' '))
+  try {
+    await runPromise(execFile(cmd, args))
+  } catch (e) {
+    console.error(e.message)
+    if (exitOnError) process.exit(1)
+  }
+}
+
+async function publish(version) {
+  packageJson.version = version
+  fs.writeFileSync('package.json', JSON.stringify(packageJson, null, 2) + '\n')
+
+  await run('git add package.json')
+  await run(`git commit -m "Bump version to ${version}"`)
+
+  if (fs.existsSync(path.join(process.cwd(), 'script/build'))) {
+    await run('script/build')
+    await run('git add example/dist')
+    await run(`git commit -m "Build version ${version}"`)
+  }
+
+  await run(`git tag v${version}`)
+
+  // log in to npm first if needed
+  try {
+    await runPromise(exec('npm whoami'))
+  } catch {
+    await runInteractive('npm', ['login'])
+  }
+
+  // publish to npm before pushing, so a failed publish leaves nothing on the remote
+  await runInteractive('npm', ['publish'])
+
+  await run('git push')
+  await run('git push --tags')
+
+  const answer = await question('Do you want to create a GitHub release? (y/n): ')
+  if (answer === 'y') {
+    const notes = await question('Enter notes for the release (optional): ')
+    const args = ['release', 'create', `v${version}`, '--title', `v${version}`, '--latest']
+    if (notes.trim() !== '') {
+      args.push('--notes', notes)
+    } else {
+      args.push('--generate-notes')
+    }
+    await runFile('gh', args)
+  }
+}
+
+async function init() {
+  if (!packageJson.version) {
+    console.log('No version found in package.json')
+    process.exit(1)
+  }
+
+  if (argVersion && !isValidVersion(argVersion)) {
+    console.log('Invalid version: ', argVersion)
+    console.log('Current version: ', packageJson.version)
+    process.exit(1)
+  }
+
+  if (argVersion && packageJson.version === argVersion) {
+    console.log('Version is already ', argVersion)
+    process.exit(1)
+  }
+
+  if (!argVersion) {
+    console.log('Current version: ', packageJson.version)
+    const version = incrementPatchVersion(packageJson.version)
+    const answer = version ? await question(`Do you want to increment the version to ${version}? (y/n) `) : 'n'
+    if (answer === 'y') {
+      await publish(version)
+    } else {
+      const desiredVersion = await question(`Enter the desired version: (or press enter to use ${packageJson.version})`)
+      if (desiredVersion.trim() === '') {
+        await publish(packageJson.version)
+      } else {
+        if (!isValidVersion(desiredVersion)) {
+          console.log('Invalid version: ', desiredVersion)
+          process.exit(1)
+        }
+        await publish(desiredVersion)
+      }
+    }
+  } else {
+    await publish(argVersion)
+  }
+}
+init()