esupgrade 2025.3.0 → 2025.3.2

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

@@ -176,7 +176,7 @@ function processFiles(patterns, options) {
       const totalChanges = allChanges.length
 
       console.log(
-        `${modifiedCount} file(s) need upgrading (${totalChanges} change${totalChanges !== 1 ? "s" : ""}, ${typeCount} type${typeCount !== 1 ? "s" : ""})`,
+        `${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")
@@ -187,7 +187,7 @@ function processFiles(patterns, options) {
   } else {
     console.log("")
     if (modifiedCount > 0) {
-      console.log(`✓ ${modifiedCount} file(s) upgraded`)
+      console.log(`✓ ${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} upgraded`)
     } else {
       console.log("All files are up to date")
     }

package/package.json

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

package/src/widelyAvailable.js

@@ -68,17 +68,32 @@ export function concatToTemplateLiteral(j, root) {
         return false
       }
 
-      const addStringPart = (value) => {
+      // Helper to get the raw value of a string literal (preserving escape sequences)
+      const getRawStringValue = (node) => {
+        // In string literals, backslashes are used for escape sequences
+        // In template literals, backslashes in the raw value also need escaping
+        // So we need to double the backslashes: \\ -> \\\\
+        // Note: node.extra.rawValue is always defined for string literals with the current parser
+        return node.extra.rawValue.replace(/\\/g, "\\\\")
+      }
+
+      const addStringPart = (stringNode) => {
+        // Store both the raw and cooked values
+        const rawValue = getRawStringValue(stringNode)
+        const cookedValue = stringNode.value
+
         if (parts.length === 0 || expressions.length >= parts.length) {
-          parts.push(value)
+          parts.push({ raw: rawValue, cooked: cookedValue })
         } else {
-          parts[parts.length - 1] += value
+          const lastPart = parts[parts.length - 1]
+          lastPart.raw += rawValue
+          lastPart.cooked += cookedValue
         }
       }
 
       const addExpression = (expr) => {
         if (parts.length === 0) {
-          parts.push("")
+          parts.push({ raw: "", cooked: "" })
         }
         expressions.push(expr)
       }
@@ -103,8 +118,8 @@ export function concatToTemplateLiteral(j, root) {
               // Left is also a + expression - recurse
               flatten(node.left, stringContext)
             } else if (isStringLiteral(node.left)) {
-              // Left is a string literal
-              addStringPart(node.left.value)
+              // Left is a string literal - use raw value to preserve escape sequences
+              addStringPart(node.left)
             } else {
               // Left is some other expression
               addExpression(node.left)
@@ -121,8 +136,8 @@ export function concatToTemplateLiteral(j, root) {
                 flatten(node.right, rightInStringContext)
               }
             } else if (isStringLiteral(node.right)) {
-              // Right is a string literal
-              addStringPart(node.right.value)
+              // Right is a string literal - use raw value to preserve escape sequences
+              addStringPart(node.right)
             } else {
               // Right is some other expression
               addExpression(node.right)
@@ -135,12 +150,15 @@ export function concatToTemplateLiteral(j, root) {
 
       // Ensure we have the right number of quasis (one more than expressions)
       while (parts.length <= expressions.length) {
-        parts.push("")
+        parts.push({ raw: "", cooked: "" })
       }
 
       // Create template literal
       const quasis = parts.map((part, i) =>
-        j.templateElement({ raw: part, cooked: part }, i === parts.length - 1),
+        j.templateElement(
+          { raw: part.raw, cooked: part.cooked },
+          i === parts.length - 1,
+        ),
       )
 
       const templateLiteral = j.templateLiteral(quasis, expressions)
@@ -913,62 +931,6 @@ export function anonymousFunctionToArrow(j, root) {
     return found
   }
 
-  // Helper to check if a node or its descendants use 'super'
-  const usesSuper = (node) => {
-    let found = false
-
-    const visit = (n) => {
-      if (!n || typeof n !== "object" || found) return
-
-      // If we encounter a nested function, don't traverse into it
-      // as it has its own 'super' binding context
-      if (n.type === "FunctionExpression" || n.type === "FunctionDeclaration") {
-        return
-      }
-
-      // Check if this is a 'super' node
-      if (n.type === "Super") {
-        found = true
-        return
-      }
-
-      // Traverse all child nodes
-      for (const key in n) {
-        if (
-          key === "loc" ||
-          key === "start" ||
-          key === "end" ||
-          key === "tokens" ||
-          key === "comments" ||
-          key === "type"
-        ) {
-          continue
-        }
-        const value = n[key]
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            visit(item)
-            if (found) return
-          }
-        } else if (value && typeof value === "object") {
-          visit(value)
-        }
-      }
-    }
-
-    // Start visiting from the function body's child nodes
-    // Don't check the body node itself, check its contents
-    // Note: FunctionExpression.body is always a BlockStatement
-    if (node.type === "BlockStatement" && node.body) {
-      for (const statement of node.body) {
-        visit(statement)
-        if (found) break
-      }
-    }
-
-    return found
-  }
-
   root
     .find(j.FunctionExpression)
     .filter((path) => {
@@ -996,10 +958,8 @@ export function anonymousFunctionToArrow(j, root) {
         return false
       }
 
-      // Skip if it uses 'super'
-      if (usesSuper(node.body)) {
-        return false
-      }
+      // Note: We don't need to check for 'super' because using super in a
+      // function expression is a syntax error and will never parse successfully
 
       return true
     })