esupgrade 2025.3.1 → 2025.3.3

package/README.md

@@ -40,6 +40,12 @@ pre-commit run esupgrade --all-files
 npx esupgrade --help
 ```
 
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-wordmark-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-wordmark.svg">
+  <img alt="Baseline: widely available" src="https://web-platform-dx.github.io/web-features/assets/img/baseline-wordmark.svg" height="32" align="right">
+</picture>
+
 ## Browser Support & Baseline
 
 All transformations are based on [Web Platform Baseline][baseline] features. Baseline tracks which web platform features are safe to use across browsers.
@@ -229,7 +235,28 @@ Supports:
 +});
 ```
 
+## Versioning
+
+esupgrade uses the [calver] `YYYY.MINOR.PATCH` versioning scheme.
+
+The year indicates the baseline version. New transformations are added in minor releases, while patches are reserved for bug fixes.
+
+## Related Projects
+
+Thanks to these projects for inspiring esupgrade:
+
+- @asottile's [pyupgrade] for Python
+- @adamchainz' [django-upgrade] for Django
+
+### Distinction
+
+lebab is a similar project that focuses on ECMAScript 6+ transformations without considering browser support.
+esupgrade is distinct in that it applies transformations that are safe based on Baseline browser support.
+Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is limited to JavaScript.
+
 [baseline]: https://web.dev/baseline/
+[calver]: https://calver.org/
+[django-upgrade]: https://github.com/adamchainz/django-upgrade
 [mdn-arrow-functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
 [mdn-const]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
 [mdn-exponentiation]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation
@@ -240,3 +267,4 @@ Supports:
 [mdn-spread]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax
 [mdn-template-literals]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
 [pre-commit]: https://pre-commit.com/
+[pyupgrade]: https://github.com/asottile/pyupgrade

package/bin/esupgrade.js

@@ -2,201 +2,317 @@
 
 import fs from "fs"
 import path from "path"
+import os from "os"
+import { Worker } from "worker_threads"
+import { once } from "events"
 import { Command, Option } from "commander"
-import { transform } from "../src/index.js"
+import { fileURLToPath } from "url"
+import process from "node:process"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
 /**
  * CLI tool for esupgrade
  */
 
-const program = new Command()
-
-program
-  .name("esupgrade")
-  .description("Auto-upgrade your JavaScript syntax")
-  .argument("[files...]", "Files or directories to process")
-  .addOption(
-    new Option("--baseline <level>", "Set baseline level for transformations")
-      .choices(["widely-available", "newly-available"])
-      .default("widely-available"),
-  )
-  .option("--check", "Report which files need upgrading and exit with code 1 if any do")
-  .option(
-    "--write",
-    "Write changes to files (default: true unless only --check is specified)",
-  )
-  .action((files, options) => {
-    if (files.length === 0) {
-      console.error("Error: No files specified")
-      program.help()
-    }
+/**
+ * Handles worker thread execution for file processing
+ */
+class WorkerRunner {
+  constructor(workerPath) {
+    this.workerPath = workerPath
+  }
 
-    // Handle check/write options - they are not mutually exclusive
-    // Default: write is true unless ONLY --check is specified (no --write)
-    const shouldWrite = options.write !== undefined ? options.write : !options.check
-    const shouldCheck = options.check || false
+  /**
+   * Run a worker thread to process a file
+   */
+  async run(filePath, baseline) {
+    const worker = new Worker(this.workerPath, {
+      workerData: { filePath, baseline },
+    })
 
-    const processingOptions = {
-      baseline: options.baseline,
-      write: shouldWrite,
-      check: shouldCheck,
-    }
+    const [message] = await once(worker, "message")
+    return message
+  }
+}
 
-    processFiles(files, processingOptions)
-  })
+/**
+ * Processes individual files and handles output
+ */
+class FileProcessor {
+  constructor(workerRunner) {
+    this.workerRunner = workerRunner
+  }
 
-function findFiles(patterns) {
-  const files = []
+  /**
+   * @typedef {Object} ProcessResult
+   * @property {boolean} modified - Whether the file was modified
+   * @property {Array} changes - List of changes made
+   * @property {boolean} error - Whether an error occurred during processing
+   */
 
-  for (const pattern of patterns) {
+  /**
+   * Process a file using a worker thread
+   *
+   * @param {string} filePath - Path to the file to process
+   * @param {Object} options - Processing options
+   * @param {string} options.baseline - Baseline level for transformations
+   * @param {boolean} options.check - Whether to only check for changes
+   * @param {boolean} options.write - Whether to write changes to file
+   * @returns {Promise<ProcessResult>} Result of processing
+   */
+  async processFile(filePath, options) {
     try {
-      const stats = fs.statSync(pattern)
-
-      if (stats.isFile()) {
-        files.push(pattern)
-      } else if (stats.isDirectory()) {
-        // Recursively find .js, .jsx, .ts, .tsx files
-        const dirFiles = walkDirectory(pattern)
-        files.push(...dirFiles)
+      const workerResult = await this.workerRunner.run(filePath, options.baseline)
+
+      if (!workerResult.success) {
+        console.error(`✗ Error: ${filePath}: ${workerResult.error}`)
+        return { modified: false, changes: [], error: true }
+      }
+
+      const result = workerResult.result
+
+      if (result.modified) {
+        if (options.check) {
+          this.#reportChanges(filePath, result.changes)
+        }
+
+        if (options.write) {
+          fs.writeFileSync(filePath, result.code, "utf8")
+          if (!options.check) {
+            console.log(`✓ ${filePath}`)
+          } else {
+            console.log(`  ✓ written`)
+          }
+        }
+
+        return { modified: true, changes: result.changes, error: false }
+      } else {
+        if (!options.check) {
+          console.log(`  ${filePath}`)
+        }
+        return { modified: false, changes: [], error: false }
       }
     } catch (error) {
-      console.error(`Error: Cannot access '${pattern}': ${error.message}`)
-      process.exit(1)
+      console.error(`✗ Error: ${filePath}: ${error.message}`)
+      return { modified: false, changes: [], error: true }
     }
   }
 
-  return files
+  #reportChanges(filePath, changes) {
+    const changesByType = {}
+    if (changes && changes.length > 0) {
+      for (const change of changes) {
+        if (!changesByType[change.type]) {
+          changesByType[change.type] = 0
+        }
+        changesByType[change.type]++
+      }
+    }
+
+    const transformations = Object.keys(changesByType)
+      .map((type) =>
+        type
+          .replace(/([A-Z])/g, " $1")
+          .trim()
+          .toLowerCase(),
+      )
+      .join(", ")
+
+    console.log(`✗ ${filePath}`)
+    if (transformations) {
+      console.log(`  ${transformations}`)
+    }
+  }
 }
 
-function walkDirectory(dir) {
-  const files = []
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
+/**
+ * Manages a pool of workers for parallel file processing
+ */
+class WorkerPool {
+  constructor(fileProcessor, maxWorkers = os.cpus().length) {
+    this.fileProcessor = fileProcessor
+    this.maxWorkers = maxWorkers
+  }
 
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name)
+  /**
+   * Process files with a worker pool for better CPU utilization
+   */
+  async processFiles(files, options) {
+    const results = new Array(files.length)
+    let fileIndex = 0
 
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === ".git") {
-        continue
-      }
-      files.push(...walkDirectory(fullPath))
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name)
-      if ([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"].includes(ext)) {
-        files.push(fullPath)
+    // Worker pool pattern - each worker processes files until queue is empty
+    const processNext = async () => {
+      while (fileIndex < files.length) {
+        const currentIndex = fileIndex++
+        const file = files[currentIndex]
+        results[currentIndex] = await this.fileProcessor.processFile(file, options)
       }
     }
-  }
 
-  return files
+    // Start worker pool and wait for all to complete
+    const workerCount = Math.min(this.maxWorkers, files.length)
+    const workers = Array.from({ length: workerCount }, () => processNext())
+    await Promise.all(workers)
+
+    return results
+  }
 }
 
-function processFile(filePath, options) {
-  try {
-    const code = fs.readFileSync(filePath, "utf8")
-    const result = transform(code, options.baseline)
-
-    if (result.modified) {
-      if (options.check) {
-        // Group changes by type for summary
-        const changesByType = {}
-        if (result.changes && result.changes.length > 0) {
-          for (const change of result.changes) {
-            if (!changesByType[change.type]) {
-              changesByType[change.type] = 0
-            }
-            changesByType[change.type]++
-          }
-        }
+/**
+ * Finds JavaScript files from patterns
+ */
+class FileFinder {
+  static IGNORED_DIRS = ["node_modules", ".git"]
+  static JS_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
 
-        const transformations = Object.keys(changesByType)
-          .map((type) => {
-            const displayName = type
-              .replace(/([A-Z])/g, " $1")
-              .trim()
-              .toLowerCase()
-            return displayName
-          })
-          .join(", ")
-
-        console.log(`✗ ${filePath}`)
-        if (transformations) {
-          console.log(`  ${transformations}`)
-        }
-      }
+  constructor() {}
 
-      if (options.write) {
-        fs.writeFileSync(filePath, result.code, "utf8")
-        if (!options.check) {
-          console.log(`✓ ${filePath}`)
-        } else {
-          console.log(`  ✓ written`)
+  /**
+   * Find files matching patterns
+   */
+  *find(patterns) {
+    for (const pattern of patterns) {
+      try {
+        const stats = fs.statSync(pattern)
+
+        if (stats.isFile()) {
+          yield pattern
+        } else if (stats.isDirectory()) {
+          yield* this._walkDirectory(pattern)
         }
+      } catch (error) {
+        console.error(`Error: Cannot access '${pattern}': ${error.message}`)
+        process.exit(1)
       }
+    }
+  }
 
-      return { modified: true, changes: result.changes }
-    } else {
-      if (!options.check) {
-        console.log(`  ${filePath}`)
+  *_walkDirectory(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (FileFinder.IGNORED_DIRS.includes(entry.name)) {
+          continue
+        }
+        yield* this._walkDirectory(fullPath)
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name)
+        if (FileFinder.JS_EXTENSIONS.includes(ext)) {
+          yield fullPath
+        }
       }
-      return { modified: false, changes: [] }
     }
-  } catch (error) {
-    console.error(`✗ Error: ${filePath}: ${error.message}`)
-    return { modified: false, changes: [] }
   }
 }
 
-function processFiles(patterns, options) {
-  const files = findFiles(patterns)
-
-  if (files.length === 0) {
-    console.log("No JavaScript files found")
-    process.exit(0)
+/**
+ * Orchestrates the CLI application
+ */
+class CLIRunner {
+  constructor(workerPath) {
+    const workerRunner = new WorkerRunner(workerPath)
+    const fileProcessor = new FileProcessor(workerRunner)
+    this.workerPool = new WorkerPool(fileProcessor)
+    this.fileFinder = new FileFinder()
   }
 
-  let modifiedCount = 0
-  const allChanges = []
+  /**
+   * Process files and report results
+   */
+  async run(patterns, options) {
+    const files = [...this.fileFinder.find(patterns)]
 
-  for (const file of files) {
-    const result = processFile(file, options)
-    if (result.modified) {
-      modifiedCount++
-      allChanges.push(...result.changes)
+    if (files.length === 0) {
+      console.log("No JavaScript files found")
+      process.exit(0)
     }
+
+    const results = await this.workerPool.processFiles(files, options)
+    this.#reportSummary(results, options)
   }
 
-  // Summary
-  if (options.check) {
+  #reportSummary(results, options) {
+    let modifiedCount = 0
+    const allChanges = results.flatMap((result) =>
+      result.modified ? (modifiedCount++, result.changes) : [],
+    )
+
+    const errorCount = results.filter((result) => result.error).length
+
     console.log("")
-    if (modifiedCount > 0) {
-      // Count unique transformation types
-      const transformTypes = new Set(allChanges.map((c) => c.type))
-      const typeCount = transformTypes.size
-      const totalChanges = allChanges.length
-
-      console.log(
-        `${modifiedCount} file(s) need upgrading (${totalChanges} change${totalChanges !== 1 ? "s" : ""}, ${typeCount} type${typeCount !== 1 ? "s" : ""})`,
-      )
-      if (options.write) {
-        console.log("Changes have been written")
+
+    if (options.check) {
+      if (modifiedCount > 0) {
+        const transformTypes = new Set(allChanges.map((c) => c.type))
+        const typeCount = transformTypes.size
+        const totalChanges = allChanges.length
+
+        console.log(
+          `${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} need${modifiedCount === 1 ? "s" : ""} upgrading (${totalChanges} change${totalChanges !== 1 ? "s" : ""}, ${typeCount} type${typeCount !== 1 ? "s" : ""})`,
+        )
+        if (options.write) {
+          console.log("Changes have been written")
+        }
+      } else {
+        console.log("All files are up to date")
       }
     } else {
-      console.log("All files are up to date")
+      if (modifiedCount > 0) {
+        console.log(`✓ ${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} upgraded`)
+      } else {
+        console.log("All files are up to date")
+      }
     }
-  } else {
-    console.log("")
-    if (modifiedCount > 0) {
-      console.log(`✓ ${modifiedCount} file(s) upgraded`)
-    } else {
-      console.log("All files are up to date")
+
+    // Errors take precedence over --check flag.
+    // Exit with error code if any file processing errors occurred.
+    if (errorCount > 0) {
+      process.exit(1)
     }
-  }
 
-  // Exit with code 1 if --check specified and there were changes
-  if (options.check && modifiedCount > 0) {
-    process.exit(1)
+    if (options.check && modifiedCount > 0) {
+      process.exit(1)
+    }
   }
 }
 
+// Initialize CLI
+const program = new Command()
+const cliRunner = new CLIRunner(path.join(__dirname, "../src/worker.js"))
+
+program
+  .name("esupgrade")
+  .description("Auto-upgrade your JavaScript syntax")
+  .argument("<files...>", "Files or directories to process")
+  .addOption(
+    new Option("--baseline <level>", "Set baseline level for transformations")
+      .choices(["widely-available", "newly-available"])
+      .default("widely-available"),
+  )
+  .option("--check", "Report which files need upgrading and exit with code 1 if any do")
+  .option(
+    "--write",
+    "Write changes to files (default: true unless only --check is specified)",
+  )
+  .action(async (files, options) => {
+    // Handle check/write options - they are not mutually exclusive
+    // Default: write is true unless ONLY --check is specified (no --write)
+    const shouldWrite = options.write !== undefined ? options.write : !options.check
+    const shouldCheck = options.check || false
+
+    const processingOptions = {
+      baseline: options.baseline,
+      write: shouldWrite,
+      check: shouldCheck,
+    }
+
+    await cliRunner.run(files, processingOptions)
+  })
+
 program.parse()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esupgrade",
-  "version": "2025.3.1",
+  "version": "2025.3.3",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -11,10 +11,10 @@ import * as newlyAvailable from "./newlyAvailable.js"
  */
 
 /**
- * Transform JavaScript code using the specified transformers
- * @param {string} code - The source code to transform
- * @param {string} baseline - Baseline level ('widely-available' or 'newly-available')
- * @returns {TransformResult} - Object with { code, modified, changes }
+ * Transform JavaScript code using the specified transformers.
+ * @param {string} code - The source code to transform.
+ * @param {string} baseline - Baseline level ('widely-available' or 'newly-available').
+ * @returns {TransformResult} Object with transformed code, modification status, and changes.
  */
 export function transform(code, baseline = "widely-available") {
   const j = jscodeshift.withParser("tsx")
@@ -22,11 +22,14 @@ export function transform(code, baseline = "widely-available") {
 
   let modified = false
   const allChanges = []
-  let transformers = widelyAvailable
-  if (baseline === "newly-available")
-    transformers = { ...widelyAvailable, ...newlyAvailable }
-  for (const name in transformers) {
-    const result = transformers[name](j, root)
+
+  const transformers =
+    baseline === "newly-available"
+      ? { ...widelyAvailable, ...newlyAvailable }
+      : widelyAvailable
+
+  for (const transformer of Object.values(transformers)) {
+    const result = transformer(j, root)
     if (result.modified) {
       modified = true
       allChanges.push(...result.changes)

package/src/worker.js

@@ -0,0 +1,26 @@
+import { parentPort, workerData } from "worker_threads"
+import fs from "fs"
+import { transform } from "./index.js"
+
+/**
+ * Worker thread for processing files in parallel.
+ */
+
+const { filePath, baseline } = workerData
+
+try {
+  const code = fs.readFileSync(filePath, "utf8")
+  const result = transform(code, baseline)
+
+  parentPort.postMessage({
+    success: true,
+    filePath,
+    result,
+  })
+} catch (error) {
+  parentPort.postMessage({
+    success: false,
+    filePath,
+    error: error.message,
+  })
+}

package/tests/cli.test.js

@@ -27,10 +27,10 @@ describe("CLI", () => {
 
     assert.match(
       result.stderr,
-      /Error: No files specified/,
+      /error: missing required argument 'files'/,
       "displays error for no files",
     )
-    assert.equal(result.status, 0, "exits with 0 when showing help")
+    assert.equal(result.status, 1, "exits with 1 when showing help")
   })
 
   test("transform a single file with --write", () => {
@@ -46,7 +46,7 @@ describe("CLI", () => {
       /const x = 1/,
       "transforms var to const",
     )
-    assert.match(result.stdout, /✓ 1 file\(s\) upgraded/, "reports 1 file upgraded")
+    assert.match(result.stdout, /✓ 1 file upgraded/, "reports 1 file upgraded")
     assert.equal(result.status, 0, "exits successfully")
   })
 
@@ -113,7 +113,7 @@ describe("CLI", () => {
     assert.match(result.stdout, /✗/, "indicates changes needed")
     assert.match(
       result.stdout,
-      /1 file\(s\) need upgrading/,
+      /1 file needs upgrading/,
       "reports 1 file needs upgrading",
     )
     assert.equal(result.status, 1, "exits with 1 when changes needed")
@@ -178,7 +178,7 @@ describe("CLI", () => {
 
     assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
     assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
-    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.match(result.stdout, /2 files upgraded/, "reports 2 files upgraded")
     assert.equal(result.status, 0, "exits successfully")
   })
 
@@ -215,7 +215,7 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /4 file\(s\) upgraded/, "reports 4 files upgraded")
+    assert.match(result.stdout, /4 files upgraded/, "reports 4 files upgraded")
     assert.equal(result.status, 0, "exits successfully")
   })
 
@@ -290,7 +290,7 @@ describe("CLI", () => {
 
     assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
     assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
-    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.match(result.stdout, /2 files upgraded/, "reports 2 files upgraded")
     assert.equal(result.status, 0, "exits successfully")
   })
 
@@ -361,7 +361,7 @@ describe("CLI", () => {
     assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("handle syntax errors gracefully", () => {
+  test("exit with 1 on syntax errors", () => {
     const testFile = path.join(tempDir, "test.js")
     fs.writeFileSync(testFile, `var x = {{{;`)
 
@@ -370,7 +370,50 @@ describe("CLI", () => {
     })
 
     assert.match(result.stderr, /✗ Error:/, "displays error for syntax issues")
-    assert.equal(result.status, 0, "continues despite errors")
+    assert.equal(result.status, 1, "exits with 1 on errors")
+  })
+
+  test("exit with 1 on parsing errors with --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for parsing issues")
+    assert.equal(result.status, 1, "exits with 1 on errors with --check")
+  })
+
+  test("exit with 1 on parsing errors without --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for parsing issues")
+    assert.equal(result.status, 1, "exits with 1 on errors without --check")
+  })
+
+  test("exit with 1 on errors even with valid files", () => {
+    const validFile = path.join(tempDir, "valid.js")
+    const invalidFile = path.join(tempDir, "invalid.js")
+    fs.writeFileSync(validFile, `var x = 1;`)
+    fs.writeFileSync(invalidFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, validFile, invalidFile, "--check"],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for invalid file")
+    assert.match(result.stdout, /valid\.js/, "processes valid file")
+    assert.equal(result.status, 1, "exits with 1 when any file has errors")
   })
 
   test("handle mixed directory and file arguments", () => {
@@ -388,7 +431,36 @@ describe("CLI", () => {
 
     assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
     assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
-    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.match(result.stdout, /2 files upgraded/, "reports 2 files upgraded")
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("show individual file markers for mixed results", () => {
+    const file1 = path.join(tempDir, "test1.js")
+    const file2 = path.join(tempDir, "test2.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `const y = 2;`) // Already upgraded
+
+    const result = spawnSync(process.execPath, [CLI_PATH, file1, file2, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /✓/, "shows check mark for modified file")
+    assert.match(result.stdout, /test2\.js/, "shows unmodified file path")
     assert.equal(result.status, 0, "exits successfully")
   })
+
+  test("exit with 1 on file write errors", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `var x = 1;`)
+    // Make file read-only to trigger write error
+    fs.chmodSync(testFile, 0o444)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for write issues")
+    assert.equal(result.status, 1, "exits with 1 on write errors")
+  })
 })

package/tests/newlyAvailable.test.js

@@ -5,20 +5,12 @@ import { transform } from "../src/index.js"
 describe("newly-available", () => {
   describe("Promise.try", () => {
     test("transforms resolve call with argument", () => {
-      assert(
-        transform(
-          `const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).modified,
-        "transform Promise constructor to Promise.try",
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).code,
-        /Promise\.try/,
+      const result = transform(
+        `const p = new Promise((resolve) => resolve(getData()));`,
+        "newly-available",
       )
+      assert(result.modified, "transform Promise constructor to Promise.try")
+      assert.match(result.code, /Promise\.try/)
     })
 
     test("not available in widely-available baseline", () => {
@@ -33,347 +25,199 @@ describe("newly-available", () => {
     })
 
     test("transforms function passed to resolve", () => {
-      assert(
-        transform(
-          `const p = new Promise((resolve) => setTimeout(resolve));`,
-          "newly-available",
-        ).modified,
+      const result = transform(
+        `const p = new Promise((resolve) => setTimeout(resolve));`,
+        "newly-available",
       )
+      assert(result.modified)
       assert.match(
-        transform(
-          `const p = new Promise((resolve) => setTimeout(resolve));`,
-          "newly-available",
-        ).code,
+        result.code,
         /Promise\.try\(setTimeout\)/,
         "transform to Promise.try(setTimeout) not Promise.try(() => setTimeout(resolve))",
       )
-      assert.doesNotMatch(
-        transform(
-          `const p = new Promise((resolve) => setTimeout(resolve));`,
-          "newly-available",
-        ).code,
-        /resolve/,
-      )
+      assert.doesNotMatch(result.code, /resolve/)
     })
 
     test("skip when awaited", () => {
-      assert(
-        !transform(
-          `async function foo() {
-  await new Promise((resolve) => setTimeout(resolve, 1000));
-}`,
-          "newly-available",
-        ).modified,
-        "do not transform awaited Promises",
-      )
-      assert.match(
-        transform(
-          `async function foo() {
-  await new Promise((resolve) => setTimeout(resolve, 1000));
-}`,
-          "newly-available",
-        ).code,
-        /await new Promise/,
-      )
-      assert.doesNotMatch(
-        transform(
-          `async function foo() {
+      const result = transform(
+        `async function foo() {
   await new Promise((resolve) => setTimeout(resolve, 1000));
 }`,
-          "newly-available",
-        ).code,
-        /Promise\.try/,
+        "newly-available",
       )
+      assert(!result.modified, "do not transform awaited Promises")
+      assert.match(result.code, /await new Promise/)
+      assert.doesNotMatch(result.code, /Promise\.try/)
     })
 
     test("skip non-Promise constructors", () => {
-      assert(
-        !transform(
-          `const p = new MyPromise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new MyPromise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).code,
-        /new MyPromise/,
+      const result = transform(
+        `const p = new MyPromise((resolve) => resolve(getData()));`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new MyPromise/)
     })
 
     test("skip with 0 arguments", () => {
-      assert(!transform(`const p = new Promise();`, "newly-available").modified)
-      assert.match(
-        transform(`const p = new Promise();`, "newly-available").code,
-        /new Promise\(\)/,
-      )
+      const result = transform(`const p = new Promise();`, "newly-available")
+      assert(!result.modified)
+      assert.match(result.code, /new Promise\(\)/)
     })
 
     test("skip with multiple arguments", () => {
-      assert(
-        !transform(
-          `const p = new Promise((resolve) => resolve(1), extraArg);`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => resolve(1), extraArg);`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve) => resolve(1), extraArg);`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with non-function argument", () => {
-      assert(!transform(`const p = new Promise(executor);`, "newly-available").modified)
-      assert.match(
-        transform(`const p = new Promise(executor);`, "newly-available").code,
-        /new Promise\(executor\)/,
-      )
+      const result = transform(`const p = new Promise(executor);`, "newly-available")
+      assert(!result.modified)
+      assert.match(result.code, /new Promise\(executor\)/)
     })
 
     test("skip with 0 params", () => {
-      assert(
-        !transform(
-          `const p = new Promise(() => console.log('test'));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise(() => console.log('test'));`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise(() => console.log('test'));`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with more than 2 params", () => {
-      assert(
-        !transform(
-          `const p = new Promise((resolve, reject, extra) => resolve(1));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve, reject, extra) => resolve(1));`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve, reject, extra) => resolve(1));`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("transforms block statement with resolve call", () => {
-      assert(
-        transform(
-          `const p = new Promise((resolve) => { resolve(getData()); });`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => { resolve(getData()); });`,
-          "newly-available",
-        ).code,
-        /Promise\.try/,
+      const result = transform(
+        `const p = new Promise((resolve) => { resolve(getData()); });`,
+        "newly-available",
       )
+      assert(result.modified)
+      assert.match(result.code, /Promise\.try/)
     })
 
     test("skip with arrow function expression body as function call", () => {
+      const result = transform(
+        `const p = new Promise((resolve) => computeValue());`,
+        "newly-available",
+      )
       assert(
-        !transform(
-          `const p = new Promise((resolve) => computeValue());`,
-          "newly-available",
-        ).modified,
+        !result.modified,
         "do not transform because computeValue() is not calling resolve",
       )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => computeValue());`,
-          "newly-available",
-        ).code,
-        /new Promise/,
-      )
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with arrow function returning a value directly", () => {
+      const result = transform(
+        `const p = new Promise((resolve) => someFunction(arg1, arg2));`,
+        "newly-available",
+      )
       assert(
-        !transform(
-          `const p = new Promise((resolve) => someFunction(arg1, arg2));`,
-          "newly-available",
-        ).modified,
+        !result.modified,
         "do not transform function call that doesn't involve resolve",
       )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => someFunction(arg1, arg2));`,
-          "newly-available",
-        ).code,
-        /new Promise/,
-      )
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with non-call expression body", () => {
-      assert(
-        !transform(`const p = new Promise((resolve) => someValue);`, "newly-available")
-          .modified,
-      )
-      assert.match(
-        transform(`const p = new Promise((resolve) => someValue);`, "newly-available")
-          .code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve) => someValue);`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with wrong number of arguments to resolve", () => {
-      assert(
-        !transform(
-          `const p = new Promise((resolve) => func(resolve, extra));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => func(resolve, extra));`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve) => func(resolve, extra));`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with non-identifier resolve", () => {
-      assert(
-        !transform(`const p = new Promise((resolve) => func(123));`, "newly-available")
-          .modified,
-      )
-      assert.match(
-        transform(`const p = new Promise((resolve) => func(123));`, "newly-available")
-          .code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve) => func(123));`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with resolve call with 0 arguments", () => {
-      assert(
-        !transform(`const p = new Promise((resolve) => resolve());`, "newly-available")
-          .modified,
-      )
-      assert.match(
-        transform(`const p = new Promise((resolve) => resolve());`, "newly-available")
-          .code,
-        /new Promise/,
+      const result = transform(
+        `const p = new Promise((resolve) => resolve());`,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with block with multiple statements", () => {
-      assert(
-        !transform(
-          `const p = new Promise((resolve) => {
+      const result = transform(
+        `const p = new Promise((resolve) => {
         const data = getData();
         resolve(data);
       });`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => {
-        const data = getData();
-        resolve(data);
-      });`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("skip with block with non-expression statement", () => {
-      assert(
-        !transform(
-          `const p = new Promise((resolve) => {
+      const result = transform(
+        `const p = new Promise((resolve) => {
         if (true) resolve(1);
       });`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve) => {
-        if (true) resolve(1);
-      });`,
-          "newly-available",
-        ).code,
-        /new Promise/,
+        "newly-available",
       )
+      assert(!result.modified)
+      assert.match(result.code, /new Promise/)
     })
 
     test("transforms function expression", () => {
-      assert(
-        transform(
-          `const p = new Promise(function(resolve) { resolve(getData()); });`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise(function(resolve) { resolve(getData()); });`,
-          "newly-available",
-        ).code,
-        /Promise\.try/,
+      const result = transform(
+        `const p = new Promise(function(resolve) { resolve(getData()); });`,
+        "newly-available",
       )
+      assert(result.modified)
+      assert.match(result.code, /Promise\.try/)
     })
 
     test("transforms with both resolve and reject params", () => {
-      assert(
-        transform(
-          `const p = new Promise((resolve, reject) => resolve(getData()));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.match(
-        transform(
-          `const p = new Promise((resolve, reject) => resolve(getData()));`,
-          "newly-available",
-        ).code,
-        /Promise\.try/,
+      const result = transform(
+        `const p = new Promise((resolve, reject) => resolve(getData()));`,
+        "newly-available",
       )
+      assert(result.modified)
+      assert.match(result.code, /Promise\.try/)
     })
 
     test("tracks line numbers correctly", () => {
-      assert(
-        transform(
-          `// Line 1
-const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).modified,
-      )
-      assert.equal(
-        transform(
-          `// Line 1
-const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).changes.length,
-        1,
-      )
-      assert.equal(
-        transform(
-          `// Line 1
-const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).changes[0].type,
-        "promiseTry",
-      )
-      assert.equal(
-        transform(
-          `// Line 1
+      const result = transform(
+        `// Line 1
 const p = new Promise((resolve) => resolve(getData()));`,
-          "newly-available",
-        ).changes[0].line,
-        2,
+        "newly-available",
       )
+      assert(result.modified)
+      assert.equal(result.changes.length, 1)
+      assert.equal(result.changes[0].type, "promiseTry")
+      assert.equal(result.changes[0].line, 2)
     })
   })
 })

package/tests/widelyAvailable.test.js

@@ -1726,6 +1726,22 @@ const result = [1, 2].concat(other);`)
 })
 
 describe("general", () => {
+  const input = `var x = 1;`
+
+  test("baseline widely-available", () => {
+    const result = transform(input)
+
+    assert(result.modified, "transform with baseline widely-available")
+    assert.match(result.code, /const x = 1/)
+  })
+
+  test("baseline newly-available", () => {
+    const result = transform(input, "newly-available")
+
+    assert(result.modified, "transform with baseline newly-available")
+    assert.match(result.code, /const x = 1/)
+  })
+
   test("no changes", () => {
     const result = transform(`
     const x = 1;
@@ -1745,18 +1761,4 @@ describe("general", () => {
     assert.match(result.code, /const userName/)
     assert.match(result.code, /`Hello \$\{userName\}`/)
   })
-
-  test("baseline widely-available", () => {
-    const result = transform(`var x = 1;`)
-
-    assert(result.modified, "transform with baseline widely-available")
-    assert.match(result.code, /const x = 1/)
-  })
-
-  test("baseline newly-available", () => {
-    const result = transform(`var x = 1;`, "newly-available")
-
-    assert(result.modified, "transform with baseline newly-available")
-    assert.match(result.code, /const x = 1/)
-  })
 })