@take-out/scripts 0.0.28

package/src/release.ts

@@ -0,0 +1,352 @@
+// note! this is an helper script used by tamagui team for publishing the takeout packages
+// you can delete this from your own app
+
+import { run } from '@take-out/scripts/helpers/run'
+import fs, { ensureDir, writeJSON } from 'fs-extra'
+import path, { join } from 'node:path'
+import pMap from 'p-map'
+
+// avoid emitter error
+process.setMaxListeners(50)
+process.stderr.setMaxListeners(50)
+process.stdout.setMaxListeners(50)
+
+// for failed publishes that need to re-run
+const reRun = process.argv.includes('--rerun')
+const rePublish = reRun || process.argv.includes('--republish')
+const finish = process.argv.includes('--finish')
+const skipFinish = process.argv.includes('--skip-finish')
+
+const canary = process.argv.includes('--canary')
+const skipVersion = finish || rePublish || process.argv.includes('--skip-version')
+const shouldMajor = process.argv.includes('--major')
+const shouldMinor = process.argv.includes('--minor')
+const shouldPatch = process.argv.includes('--patch')
+const dirty = finish || process.argv.includes('--dirty')
+const skipTest =
+  finish ||
+  rePublish ||
+  process.argv.includes('--skip-test') ||
+  process.argv.includes('--skip-tests')
+const skipBuild = finish || rePublish || process.argv.includes('--skip-build')
+const dryRun = process.argv.includes('--dry-run')
+const tamaguiGitUser = process.argv.includes('--tamagui-git-user')
+
+const curVersion = fs.readJSONSync('./packages/helpers/package.json').version
+
+// must specify version (unless republishing):
+if (!rePublish && !skipVersion && !shouldPatch && !shouldMinor && !shouldMajor) {
+  console.error(`Must specify one of --patch, --minor, or --major`)
+  process.exit(1)
+}
+
+const nextVersion = (() => {
+  if (rePublish || skipVersion) {
+    return curVersion
+  }
+
+  if (canary) {
+    return `${curVersion.replace(/(-\d+)+$/, '')}-${Date.now()}`
+  }
+
+  const curMajor = +curVersion.split('.')[0] || 0
+  const curMinor = +curVersion.split('.')[1] || 0
+  const patchAndCanary = curVersion.split('.')[2]
+  const [curPatch] = patchAndCanary.split('-')
+  const patchVersion = shouldPatch ? +curPatch + 1 : 0
+  const minorVersion = curMinor + (shouldMinor ? 1 : 0)
+  const majorVersion = curMajor + (shouldMajor ? 1 : 0)
+  const next = `${majorVersion}.${minorVersion}.${patchVersion}`
+
+  return next
+})()
+
+if (!skipVersion) {
+  console.info(` 🚀 Releasing:`)
+  console.info('  Current:', curVersion)
+  console.info(`  Next: ${nextVersion}`)
+}
+
+async function main() {
+  try {
+    // ensure we are up to date
+    // ensure we are on main
+    if (!canary) {
+      if ((await run(`git rev-parse --abbrev-ref HEAD`)).stdout.trim() !== 'main') {
+        throw new Error(`Not on main`)
+      }
+      if (!dirty && !rePublish && !finish) {
+        await run(`git pull --rebase origin main`)
+      }
+    }
+
+    const packagePaths = await getWorkspacePackages()
+    const { allPackageJsons, publishablePackages: packageJsons } =
+      await loadPackageJsons(packagePaths)
+
+    if (!finish) {
+      console.info(
+        `Publishing in order:\n\n${packageJsons.map((x) => x.name).join('\n')}`
+      )
+    }
+
+    async function checkDistDirs() {
+      await Promise.all(
+        packageJsons.map(async ({ cwd, json }) => {
+          const distDir = join(cwd, 'dist')
+          if (json.scripts?.build) {
+            if (!(await fs.pathExists(distDir))) {
+              console.warn('no dist dir!', distDir)
+              process.exit(1)
+            }
+          }
+        })
+      )
+    }
+
+    if (tamaguiGitUser) {
+      await run(`git config --global user.name 'Tamagui'`)
+      await run(`git config --global user.email 'tamagui@users.noreply.github.com`)
+    }
+
+    console.info('install and build')
+
+    if (!rePublish && !finish) {
+      await run(`bun install`)
+    }
+
+    if (!skipBuild && !finish) {
+      await run(`bun clean`)
+      await run(`bun run build`)
+      await checkDistDirs()
+    }
+
+    if (!finish) {
+      console.info('run checks')
+
+      if (!skipTest) {
+        await run(`bun lint`)
+        await run(`bun check`)
+        // await run(`bun test`)
+      }
+    }
+
+    if (!dirty && !dryRun && !rePublish) {
+      const out = await run(`git status --porcelain`)
+      if (out.stdout) {
+        throw new Error(`Has unsaved git changes: ${out.stdout}`)
+      }
+    }
+
+    if (!skipVersion && !finish) {
+      await Promise.all(
+        allPackageJsons.map(async ({ json, path }) => {
+          const next = { ...json }
+
+          next.version = nextVersion
+
+          for (const field of [
+            'dependencies',
+            'devDependencies',
+            'optionalDependencies',
+            'peerDependencies',
+          ]) {
+            const nextDeps = next[field]
+            if (!nextDeps) continue
+            for (const depName in nextDeps) {
+              // only update non-workspace internal dependencies
+              if (!nextDeps[depName].startsWith('workspace:')) {
+                if (allPackageJsons.some((p) => p.name === depName)) {
+                  nextDeps[depName] = nextVersion
+                }
+              }
+            }
+          }
+
+          await writeJSON(path, next, { spaces: 2 })
+        })
+      )
+    }
+
+    if (!finish && dryRun) {
+      console.info(`Dry run, exiting before publish`)
+      return
+    }
+
+    if (!finish && !rePublish) {
+      await run(`git diff`)
+    }
+
+    if (!finish) {
+      const tmpDir = `/tmp/one-publish`
+      await ensureDir(tmpDir)
+
+      await pMap(
+        packageJsons,
+        async ({ name, cwd }) => {
+          const publishOptions = [canary && `--tag canary`].filter(Boolean).join(' ')
+
+          // pack with workspace:* converted to versions
+          const tmpPackageDir = join(tmpDir, name.replace('/', '_'))
+          await fs.copy(cwd, tmpPackageDir, {
+            filter: (src) => {
+              // exclude node_modules to avoid symlink issues
+              return !src.includes('node_modules')
+            },
+          })
+
+          // replace workspace:* with version
+          const pkgJsonPath = join(tmpPackageDir, 'package.json')
+          const pkgJson = await fs.readJSON(pkgJsonPath)
+          for (const field of [
+            'dependencies',
+            'devDependencies',
+            'optionalDependencies',
+            'peerDependencies',
+          ]) {
+            if (!pkgJson[field]) continue
+            for (const depName in pkgJson[field]) {
+              if (pkgJson[field][depName].startsWith('workspace:')) {
+                pkgJson[field][depName] = nextVersion
+              }
+            }
+          }
+          await writeJSON(pkgJsonPath, pkgJson, { spaces: 2 })
+
+          const filename = `${name.replace('/', '_')}-package.tmp.tgz`
+          const absolutePath = `${tmpDir}/${filename}`
+          await run(`npm pack --pack-destination ${tmpDir}`, {
+            cwd: tmpPackageDir,
+            silent: true,
+          })
+
+          // rename npm's output to our expected filename
+          const npmFilename = `${name.replace('@', '').replace('/', '-')}-${nextVersion}.tgz`
+          await fs.rename(join(tmpDir, npmFilename), absolutePath)
+
+          const publishCommand = ['npm publish', absolutePath, publishOptions]
+            .filter(Boolean)
+            .join(' ')
+
+          console.info(`Publishing ${name}: ${publishCommand}`)
+
+          await run(publishCommand, {
+            cwd: tmpDir,
+          }).catch((err) => console.error(err))
+        },
+        {
+          concurrency: 15,
+        }
+      )
+
+      console.info(`✅ Published\n`)
+    }
+
+    if (!skipFinish) {
+      // then git tag, commit, push
+      if (!finish) {
+        await run(`bun install`)
+      }
+      const tagPrefix = canary ? 'canary' : 'v'
+      const gitTag = `${tagPrefix}${nextVersion}`
+
+      await finishAndCommit()
+
+      async function finishAndCommit(cwd = process.cwd()) {
+        if (!rePublish || reRun || finish) {
+          await run(`git add -A`, { cwd })
+
+          await run(`git commit -m ${gitTag}`, { cwd })
+
+          if (!canary) {
+            await run(`git tag ${gitTag}`, { cwd })
+          }
+
+          if (!dirty) {
+            // pull once more before pushing so if there was a push in interim we get it
+            await run(`git pull --rebase origin HEAD`, { cwd })
+          }
+
+          await run(`git push origin head`, { cwd })
+          if (!canary) {
+            await run(`git push origin ${gitTag}`, { cwd })
+          }
+
+          console.info(`✅ Pushed and versioned\n`)
+        }
+      }
+    }
+
+    console.info(`✅ Done\n`)
+  } catch (err) {
+    console.info('\nError:\n', err)
+    process.exit(1)
+  }
+}
+
+async function getWorkspacePackages() {
+  // read workspaces from root package.json
+  const rootPackageJson = await fs.readJSON(join(process.cwd(), 'package.json'))
+  const workspaceGlobs = rootPackageJson.workspaces || []
+
+  // resolve workspace paths
+  const packagePaths: { name: string; location: string }[] = []
+  for (const glob of workspaceGlobs) {
+    if (glob.includes('*')) {
+      // handle glob patterns like "./packages/*"
+      const baseDir = glob.replace('/*', '')
+      const fullPath = join(process.cwd(), baseDir)
+      if (await fs.pathExists(fullPath)) {
+        const dirs = await fs.readdir(fullPath)
+        for (const dir of dirs) {
+          const pkgPath = join(fullPath, dir, 'package.json')
+          if (await fs.pathExists(pkgPath)) {
+            const pkg = await fs.readJSON(pkgPath)
+            packagePaths.push({
+              name: pkg.name,
+              location: join(baseDir, dir),
+            })
+          }
+        }
+      }
+    } else {
+      // handle direct paths like "./src/start"
+      const pkgPath = join(process.cwd(), glob, 'package.json')
+      if (await fs.pathExists(pkgPath)) {
+        const pkg = await fs.readJSON(pkgPath)
+        packagePaths.push({
+          name: pkg.name,
+          location: glob,
+        })
+      }
+    }
+  }
+
+  return packagePaths
+}
+
+async function loadPackageJsons(packagePaths: { name: string; location: string }[]) {
+  const allPackageJsons = await Promise.all(
+    packagePaths
+      .filter((i) => i.location !== '.' && !i.name.startsWith('@takeout'))
+      .map(async ({ name, location }) => {
+        const cwd = path.join(process.cwd(), location)
+        const json = await fs.readJSON(path.join(cwd, 'package.json'))
+        return {
+          name,
+          cwd,
+          json,
+          path: path.join(cwd, 'package.json'),
+          directory: location,
+        }
+      })
+  )
+
+  const publishablePackages = allPackageJsons.filter(
+    (x) => !x.json.skipPublish && !x.json.private
+  )
+
+  return { allPackageJsons, publishablePackages }
+}
+
+main()

package/src/run.ts

@@ -0,0 +1,358 @@
+#!/usr/bin/env bun
+
+/**
+ * @description Run multiple scripts in parallel or sequence
+ */
+
+import { handleProcessExit } from '@take-out/scripts/helpers/handleProcessExit'
+import { spawn } from 'node:child_process'
+import { promises as fs } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+import { getIsExiting } from './helpers/run'
+import { checkNodeVersion } from './node-version-check'
+
+const colors = [
+  '\x1b[36m', // Cyan
+  '\x1b[35m', // Magenta
+  '\x1b[33m', // Yellow
+  '\x1b[32m', // Green
+  '\x1b[34m', // Blue
+  '\x1b[31m', // Red
+  '\x1b[90m', // Gray
+]
+
+const reset = '\x1b[0m'
+
+// Verbose logging flag - set to false to reduce logs
+const verbose = false
+
+// Helper function to conditionally log based on verbosity
+const log = {
+  info: (message: string) => {
+    if (verbose) console.info(message)
+  },
+  error: (message: string) => console.error(message),
+  output: (message: string) => console.info(message),
+}
+
+const MAX_RESTARTS = 3
+
+// Separate command names from flags/arguments
+const args = process.argv.slice(2)
+const runCommands = args.filter((x) => !x.startsWith('--'))
+const noRoot = args.includes('--no-root')
+const runBun = args.includes('--bun')
+const watch = args.includes('--watch') // just attempts to restart a failed process up to MAX_RESTARTS times
+
+// Collect additional flags and arguments to forward to sub-commands
+const forwardArgs = args.filter(
+  (arg) =>
+    arg.startsWith('--') && arg !== '--no-root' && arg !== '--bun' && arg !== '--watch'
+)
+
+// Get the list of scripts already being run by a parent process
+const parentRunningScripts = process.env.BUN_RUN_SCRIPTS
+  ? process.env.BUN_RUN_SCRIPTS.split(',')
+  : []
+
+const processes: ReturnType<typeof spawn>[] = []
+const { addChildProcess, exit } = handleProcessExit()
+
+if (runCommands.length === 0) {
+  log.error('Please provide at least one script name to run')
+  log.error('Example: bun run.ts watch lint test')
+  exit(1)
+}
+
+async function readPackageJson(directoryPath: string) {
+  try {
+    const packageJsonPath = join(directoryPath, 'package.json')
+    const content = await fs.readFile(packageJsonPath, 'utf8')
+    return JSON.parse(content)
+  } catch (_) {
+    return null
+  }
+}
+
+async function getWorkspacePatterns(): Promise<string[]> {
+  try {
+    const packageJson = await readPackageJson('.')
+    if (!packageJson || !packageJson.workspaces) return []
+
+    return Array.isArray(packageJson.workspaces)
+      ? packageJson.workspaces
+      : packageJson.workspaces.packages || []
+  } catch (_) {
+    log.error('Error reading workspace patterns')
+    return []
+  }
+}
+
+async function hasPackageJson(path: string): Promise<boolean> {
+  try {
+    await fs.access(join(path, 'package.json'))
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function findPackageJsonDirs(basePath: string, maxDepth = 3): Promise<string[]> {
+  if (maxDepth <= 0) return []
+
+  try {
+    const entries = await fs.readdir(basePath, { withFileTypes: true })
+    const results: string[] = []
+
+    if (await hasPackageJson(basePath)) {
+      results.push(basePath)
+    }
+
+    const subDirPromises = entries
+      .filter(
+        (entry) =>
+          entry.isDirectory() &&
+          !entry.name.startsWith('.') &&
+          entry.name !== 'node_modules'
+      )
+      .map(async (dir) => {
+        const path = join(basePath, dir.name)
+        const subdirResults = await findPackageJsonDirs(path, maxDepth - 1)
+        return subdirResults
+      })
+
+    const subdirResults = await Promise.all(subDirPromises)
+    return [...results, ...subdirResults.flat()]
+  } catch (error) {
+    log.error(`Error scanning directory ${basePath}: ${error}`)
+    return []
+  }
+}
+
+async function findWorkspaceDirectories(): Promise<string[]> {
+  const patterns = await getWorkspacePatterns()
+  if (!patterns.length) return []
+
+  const allPackageDirs = await findPackageJsonDirs('.')
+
+  const normalizePattern = (pattern: string): string => {
+    return pattern.startsWith('./') ? pattern.substring(2) : pattern
+  }
+
+  const workspaceDirs = allPackageDirs.filter((dir) => {
+    if (dir === '.') return false
+
+    const relativePath = relative('.', dir)
+    return patterns.some((pattern) => {
+      const normalizedPattern = normalizePattern(pattern)
+      const normalizedPath = normalizePattern(relativePath)
+
+      if (normalizedPattern.endsWith('/*')) {
+        const prefix = normalizedPattern.slice(0, -1)
+        return normalizedPath.startsWith(prefix)
+      }
+      return (
+        normalizedPath === normalizedPattern ||
+        normalizedPath.startsWith(normalizedPattern + '/')
+      )
+    })
+  })
+
+  return workspaceDirs
+}
+
+async function findAvailableScripts(
+  directoryPath: string,
+  scriptNames: string[]
+): Promise<string[]> {
+  const packageJson = await readPackageJson(directoryPath)
+
+  if (!packageJson || !packageJson.scripts) {
+    return []
+  }
+
+  return scriptNames.filter(
+    (scriptName) => typeof packageJson.scripts?.[scriptName] === 'string'
+  )
+}
+
+async function mapWorkspacesToScripts(
+  scriptNames: string[]
+): Promise<Map<string, { scripts: string[]; packageName: string }>> {
+  const workspaceDirs = await findWorkspaceDirectories()
+  const workspaceScriptMap = new Map<string, { scripts: string[]; packageName: string }>()
+
+  for (const dir of workspaceDirs) {
+    const availableScripts = await findAvailableScripts(dir, scriptNames)
+
+    if (availableScripts.length > 0) {
+      const packageJson = await readPackageJson(dir)
+      const packageName = packageJson?.name || dir
+      workspaceScriptMap.set(dir, {
+        scripts: availableScripts,
+        packageName,
+      })
+    }
+  }
+
+  return workspaceScriptMap
+}
+
+const runScript = async (
+  name: string,
+  cwd = '.',
+  prefixLabel: string = name,
+  restarts = 0
+) => {
+  const colorIndex = processes.length % colors.length
+  const color = colors[colorIndex]
+
+  // Capture stderr for error reporting
+  let stderrBuffer = ''
+
+  // Construct command with arguments to forward
+  const runArgs = ['run', runBun ? '--bun' : '', name, ...forwardArgs].filter(Boolean)
+
+  // Log the exact command being run
+  const commandDisplay = `bun ${runArgs.join(' ')}`
+
+  log.info(
+    `${color}${prefixLabel}${reset} Running: ${commandDisplay} (in ${resolve(cwd)})`
+  )
+
+  // Combine parent running scripts with current scripts to prevent recursion
+  const allRunningScripts = [...parentRunningScripts, ...runCommands].join(',')
+
+  const proc = spawn('bun', runArgs, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: false,
+    env: {
+      ...process.env,
+      FORCE_COLOR: '3',
+      BUN_RUN_PARENT_SCRIPT: name,
+      BUN_RUN_SCRIPTS: allRunningScripts,
+    } as any,
+    cwd: resolve(cwd),
+    detached: true,
+  })
+
+  log.info(`${color}${prefixLabel}${reset} Process started with PID: ${proc.pid}`)
+
+  processes.push(proc)
+  addChildProcess(proc)
+
+  proc.stdout.on('data', (data) => {
+    if (getIsExiting()) return // prevent output during cleanup
+    const lines = data.toString().split('\n')
+    for (const line of lines) {
+      if (line) log.output(`${color}${prefixLabel}${reset} ${line}`)
+    }
+  })
+
+  proc.stderr.on('data', (data) => {
+    const dataStr = data.toString()
+    stderrBuffer += dataStr
+
+    if (getIsExiting()) return // prevent output during cleanup
+    const lines = dataStr.split('\n')
+    for (const line of lines) {
+      if (line) log.error(`${color}${prefixLabel}${reset} ${line}`)
+    }
+  })
+
+  proc.on('error', (error) => {
+    log.error(`${color}${prefixLabel}${reset} Failed to start: ${error.message}`)
+  })
+
+  proc.on('close', (code) => {
+    if (getIsExiting()) {
+      // silently exit during cleanup
+      return
+    }
+
+    if (code && code !== 0) {
+      log.error(`${color}${prefixLabel}${reset} Process exited with code ${code}`)
+
+      if (code === 1) {
+        // Print a nicer error message with red header
+        console.error(
+          '\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m'
+        )
+        console.error('\x1b[31m❌ Run Failed\x1b[0m')
+        console.error(
+          '\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m'
+        )
+        console.error(
+          `\x1b[31mProcess "${prefixLabel}" failed with exit code ${code}\x1b[0m`
+        )
+
+        // Show the original error output without prefixes
+        if (stderrBuffer.trim()) {
+          console.error('\n\x1b[31mError output:\x1b[0m')
+          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m')
+          const cleanedStderr = stderrBuffer
+          console.error(cleanedStderr)
+          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m')
+        }
+
+        console.error('')
+
+        if (watch && restarts < MAX_RESTARTS) {
+          const newRestarts = restarts + 1
+          console.info(
+            `Restarting process ${name} (${newRestarts}/${MAX_RESTARTS} times)`
+          )
+          runScript(name, cwd, prefixLabel, newRestarts)
+        } else {
+          exit(1)
+        }
+      }
+    }
+  })
+
+  return proc
+}
+
+async function main() {
+  checkNodeVersion().catch((err) => {
+    log.error(err.message)
+    exit(1)
+  })
+
+  try {
+    if (runCommands.length > 0) {
+      // Root package.json scripts first, if not disabled
+      if (!noRoot) {
+        const scriptPromises = runCommands
+          .filter((name) => !parentRunningScripts.includes(name))
+          .map((name) => runScript(name))
+
+        await Promise.all(scriptPromises)
+      }
+
+      const workspaceScriptMap = await mapWorkspacesToScripts(runCommands)
+
+      for (const [workspace, { scripts, packageName }] of workspaceScriptMap.entries()) {
+        const workspaceScriptPromises = scripts
+          .filter((scriptName) => !parentRunningScripts.includes(scriptName))
+          .map((scriptName) =>
+            runScript(scriptName, workspace, `[${packageName}] [${scriptName}]`)
+          )
+
+        await Promise.all(workspaceScriptPromises)
+      }
+    }
+
+    if (processes.length === 0) {
+      exit(0)
+    }
+  } catch (error) {
+    log.error(`Error running scripts: ${error}`)
+    exit(1)
+  }
+}
+
+main().catch((error) => {
+  log.error(`Error running scripts: ${error}`)
+  exit(1)
+})