esupgrade 2025.1.0 → 2025.2.1

package/src/widelyAvailable.js

@@ -51,26 +51,83 @@ export function concatToTemplateLiteral(j, root) {
       const parts = []
       const expressions = []
 
-      const flatten = (node) => {
-        if (j.BinaryExpression.check(node) && node.operator === "+") {
-          flatten(node.left)
-          flatten(node.right)
-        } else if (
+      // Helper to check if a node is a string literal
+      const isStringLiteral = (node) => {
+        return (
           j.StringLiteral.check(node) ||
           (j.Literal.check(node) && typeof node.value === "string")
-        ) {
-          // Add string literal value
-          if (parts.length === 0 || expressions.length >= parts.length) {
-            parts.push(node.value)
-          } else {
-            parts[parts.length - 1] += node.value
-          }
+        )
+      }
+
+      // Helper to check if a node contains any string literal
+      const containsStringLiteral = (node) => {
+        if (isStringLiteral(node)) return true
+        if (j.BinaryExpression.check(node) && node.operator === "+") {
+          return containsStringLiteral(node.left) || containsStringLiteral(node.right)
+        }
+        return false
+      }
+
+      const addStringPart = (value) => {
+        if (parts.length === 0 || expressions.length >= parts.length) {
+          parts.push(value)
         } else {
-          // Add expression
-          if (parts.length === 0) {
-            parts.push("")
+          parts[parts.length - 1] += value
+        }
+      }
+
+      const addExpression = (expr) => {
+        if (parts.length === 0) {
+          parts.push("")
+        }
+        expressions.push(expr)
+      }
+
+      const flatten = (node, stringContext = false) => {
+        // Note: node is always a BinaryExpression when called, as non-BinaryExpression
+        // nodes are handled inline before recursing into flatten
+        if (j.BinaryExpression.check(node) && node.operator === "+") {
+          // Check if this entire binary expression contains any string literal
+          const hasString = containsStringLiteral(node)
+
+          if (!hasString && !stringContext) {
+            // This is pure numeric addition (no strings anywhere), keep as expression
+            addExpression(node)
+          } else {
+            // This binary expression is part of string concatenation
+            // Check each operand
+            const leftHasString = containsStringLiteral(node.left)
+
+            // Process left side
+            if (j.BinaryExpression.check(node.left) && node.left.operator === "+") {
+              // Left is also a + expression - recurse
+              flatten(node.left, stringContext)
+            } else if (isStringLiteral(node.left)) {
+              // Left is a string literal
+              addStringPart(node.left.value)
+            } else {
+              // Left is some other expression
+              addExpression(node.left)
+            }
+
+            // Process right side - it's in string context if left had a string
+            const rightInStringContext = stringContext || leftHasString
+            if (j.BinaryExpression.check(node.right) && node.right.operator === "+") {
+              // If right is a + expression with no strings and we're in string context, keep it as a unit
+              if (!containsStringLiteral(node.right) && rightInStringContext) {
+                addExpression(node.right)
+              } else {
+                // Right has strings or we need to flatten it
+                flatten(node.right, rightInStringContext)
+              }
+            } else if (isStringLiteral(node.right)) {
+              // Right is a string literal
+              addStringPart(node.right.value)
+            } else {
+              // Right is some other expression
+              addExpression(node.right)
+            }
           }
-          expressions.push(node)
         }
       }
 
@@ -335,3 +392,407 @@ export function arrayFromToSpread(j, root) {
 
   return { modified, changes }
 }
+
+/**
+ * Transform Math.pow() to exponentiation operator (**)
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation
+ */
+export function mathPowToExponentiation(j, root) {
+  let modified = false
+  const changes = []
+
+  root
+    .find(j.CallExpression, {
+      callee: {
+        type: "MemberExpression",
+        object: { name: "Math" },
+        property: { name: "pow" },
+      },
+    })
+    .filter((path) => {
+      // Must have exactly 2 arguments (base and exponent)
+      return path.node.arguments.length === 2
+    })
+    .forEach((path) => {
+      const node = path.node
+      const [base, exponent] = node.arguments
+
+      // Create exponentiation expression
+      const expExpression = j.binaryExpression("**", base, exponent)
+
+      j(path).replaceWith(expExpression)
+
+      modified = true
+      if (node.loc) {
+        changes.push({
+          type: "mathPowToExponentiation",
+          line: node.loc.start.line,
+        })
+      }
+    })
+
+  return { modified, changes }
+}
+
+/**
+ * Transform traditional for loops to for...of where safe
+ * Converts: for (let i = 0; i < arr.length; i++) { const item = arr[i]; ... }
+ * To: for (const item of arr) { ... }
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of
+ */
+export function forLoopToForOf(j, root) {
+  let modified = false
+  const changes = []
+
+  root
+    .find(j.ForStatement)
+    .filter((path) => {
+      const node = path.node
+
+      // Check init: must be let/const i = 0
+      if (!j.VariableDeclaration.check(node.init)) {
+        return false
+      }
+      if (node.init.declarations.length !== 1) {
+        return false
+      }
+      const initDeclarator = node.init.declarations[0]
+      if (!j.Identifier.check(initDeclarator.id)) {
+        return false
+      }
+      const indexVar = initDeclarator.id.name
+      if (!j.Literal.check(initDeclarator.init) || initDeclarator.init.value !== 0) {
+        return false
+      }
+
+      // Check test: must be i < arr.length
+      if (!j.BinaryExpression.check(node.test)) {
+        return false
+      }
+      if (node.test.operator !== "<") {
+        return false
+      }
+      if (!j.Identifier.check(node.test.left) || node.test.left.name !== indexVar) {
+        return false
+      }
+      if (!j.MemberExpression.check(node.test.right)) {
+        return false
+      }
+      if (
+        !j.Identifier.check(node.test.right.property) ||
+        node.test.right.property.name !== "length"
+      ) {
+        return false
+      }
+      if (!j.Identifier.check(node.test.right.object)) {
+        return false
+      }
+      const arrayVar = node.test.right.object.name
+
+      // Check update: must be i++ or ++i
+      if (j.UpdateExpression.check(node.update)) {
+        if (
+          !j.Identifier.check(node.update.argument) ||
+          node.update.argument.name !== indexVar ||
+          node.update.operator !== "++"
+        ) {
+          return false
+        }
+      } else {
+        return false
+      }
+
+      // Check body: must be a block statement
+      if (!j.BlockStatement.check(node.body)) {
+        return false
+      }
+
+      // Look for first statement that assigns arr[i] to a variable
+      if (node.body.body.length === 0) {
+        return false
+      }
+
+      const firstStmt = node.body.body[0]
+      if (!j.VariableDeclaration.check(firstStmt)) {
+        return false
+      }
+      if (firstStmt.declarations.length !== 1) {
+        return false
+      }
+      const varDeclarator = firstStmt.declarations[0]
+      if (!j.Identifier.check(varDeclarator.id)) {
+        return false
+      }
+      if (!j.MemberExpression.check(varDeclarator.init)) {
+        return false
+      }
+      if (
+        !j.Identifier.check(varDeclarator.init.object) ||
+        varDeclarator.init.object.name !== arrayVar
+      ) {
+        return false
+      }
+      if (
+        !j.Identifier.check(varDeclarator.init.property) ||
+        varDeclarator.init.property.name !== indexVar ||
+        varDeclarator.init.computed !== true
+      ) {
+        return false
+      }
+
+      // Check that the index variable is not used elsewhere in the body
+      const bodyWithoutFirst = node.body.body.slice(1)
+      let indexVarUsed = false
+
+      // Recursively check if identifier is used in AST nodes
+      const checkNode = (astNode) => {
+        if (!astNode || typeof astNode !== "object") return
+
+        if (astNode.type === "Identifier" && astNode.name === indexVar) {
+          indexVarUsed = true
+          return
+        }
+
+        // Traverse all properties
+        for (const key in astNode) {
+          if (
+            key === "loc" ||
+            key === "start" ||
+            key === "end" ||
+            key === "tokens" ||
+            key === "comments"
+          )
+            continue
+          const value = astNode[key]
+          if (Array.isArray(value)) {
+            value.forEach(checkNode)
+          } else if (value && typeof value === "object") {
+            checkNode(value)
+          }
+        }
+      }
+
+      bodyWithoutFirst.forEach(checkNode)
+
+      if (indexVarUsed) {
+        return false
+      }
+
+      return true
+    })
+    .forEach((path) => {
+      const node = path.node
+      const arrayVar = node.test.right.object.name
+      const itemVar = node.body.body[0].declarations[0].id.name
+      const itemKind = node.body.body[0].kind
+
+      // Create new body without the first declaration
+      const newBody = j.blockStatement(node.body.body.slice(1))
+
+      // Create for...of loop
+      const forOfLoop = j.forOfStatement(
+        j.variableDeclaration(itemKind, [j.variableDeclarator(j.identifier(itemVar))]),
+        j.identifier(arrayVar),
+        newBody,
+      )
+
+      j(path).replaceWith(forOfLoop)
+
+      modified = true
+      if (node.loc) {
+        changes.push({
+          type: "forLoopToForOf",
+          line: node.loc.start.line,
+        })
+      }
+    })
+
+  return { modified, changes }
+}
+
+/**
+ * Transform iterables' forEach() to for...of loop
+ * Handles DOM APIs like querySelectorAll, getElementsBy*, etc. and other known iterables
+ * Only transforms when forEach callback is declared inline with a function body (block statement)
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of
+ */
+export function iterableForEachToForOf(j, root) {
+  let modified = false
+  const changes = []
+
+  // Define known iterable-returning methods by their object/context
+  const knownIterableMethods = {
+    document: [
+      "querySelectorAll",
+      "getElementsByTagName",
+      "getElementsByClassName",
+      "getElementsByName",
+    ],
+  }
+
+  // Define known iterable properties
+  const knownIterableProperties = {
+    window: ["frames"],
+  }
+
+  root
+    .find(j.CallExpression)
+    .filter((path) => {
+      const node = path.node
+      // Check if this is a forEach call
+      if (
+        !j.MemberExpression.check(node.callee) ||
+        !j.Identifier.check(node.callee.property) ||
+        node.callee.property.name !== "forEach"
+      ) {
+        return false
+      }
+
+      const object = node.callee.object
+
+      // Check if this is a property access pattern like window.frames
+      if (j.MemberExpression.check(object) && !j.CallExpression.check(object)) {
+        const objectName = j.Identifier.check(object.object) ? object.object.name : null
+        const propertyName = j.Identifier.check(object.property)
+          ? object.property.name
+          : null
+
+        if (
+          objectName &&
+          propertyName &&
+          knownIterableProperties[objectName] &&
+          knownIterableProperties[objectName].includes(propertyName)
+        ) {
+          // This is a valid iterable property like window.frames - continue to callback check
+        } else {
+          // Not a known iterable property
+          return false
+        }
+      }
+      // Check for method call patterns like document.querySelectorAll()
+      else if (j.CallExpression.check(object)) {
+        // Check if it's a member expression (e.g., document.querySelectorAll)
+        if (!j.MemberExpression.check(object.callee)) {
+          return false
+        }
+
+        // Get the method name
+        const methodName = j.Identifier.check(object.callee.property)
+          ? object.callee.property.name
+          : null
+
+        if (!methodName) {
+          return false
+        }
+
+        // Verify the object is document only
+        const callerObject = object.callee.object
+        if (j.Identifier.check(callerObject)) {
+          const objectName = callerObject.name
+          // Only allow document
+          if (objectName !== "document") {
+            return false
+          }
+          // Verify method belongs to document
+          if (!knownIterableMethods.document.includes(methodName)) {
+            return false
+          }
+        }
+        // Handle cases like document.getElementById('x').querySelectorAll()
+        // Only allow these from document-originating chains
+        else if (
+          j.MemberExpression.check(callerObject) ||
+          j.CallExpression.check(callerObject)
+        ) {
+          // Check if this eventually chains from document
+          const isFromDocument = (node) => {
+            if (j.Identifier.check(node)) {
+              return node.name === "document"
+            }
+            if (j.MemberExpression.check(node)) {
+              return isFromDocument(node.object)
+            }
+            if (j.CallExpression.check(node)) {
+              if (j.MemberExpression.check(node.callee)) {
+                return isFromDocument(node.callee.object)
+              }
+            }
+            return false
+          }
+
+          if (!isFromDocument(callerObject)) {
+            return false
+          }
+
+          // Verify the method is valid for document
+          if (!knownIterableMethods.document.includes(methodName)) {
+            return false
+          }
+        } else {
+          return false
+        }
+      } else {
+        return false
+      }
+
+      // Check that forEach has a callback argument
+      if (node.arguments.length === 0) {
+        return false
+      }
+
+      const callback = node.arguments[0]
+      // Only transform if callback is an inline function (arrow or function expression)
+      if (
+        !j.ArrowFunctionExpression.check(callback) &&
+        !j.FunctionExpression.check(callback)
+      ) {
+        return false
+      }
+
+      // Only transform if the callback has a block statement body (with braces)
+      // Arrow functions with expression bodies (e.g., item => item.value) should NOT be transformed
+      if (!j.BlockStatement.check(callback.body)) {
+        return false
+      }
+
+      // Only transform if callback uses only the first parameter (element)
+      // Don't transform if it uses index or array parameters
+      const params = callback.params
+      if (params.length !== 1) {
+        return false
+      }
+
+      return true
+    })
+    .forEach((path) => {
+      const node = path.node
+      const iterable = node.callee.object
+      const callback = node.arguments[0]
+
+      const itemParam = callback.params[0]
+      const body = callback.body
+
+      // Create for...of loop
+      const forOfLoop = j.forOfStatement(
+        j.variableDeclaration("const", [j.variableDeclarator(itemParam)]),
+        iterable,
+        body,
+      )
+
+      // Replace the expression statement containing the forEach call
+      const statement = path.parent
+      if (j.ExpressionStatement.check(statement.node)) {
+        j(statement).replaceWith(forOfLoop)
+
+        modified = true
+        if (node.loc) {
+          changes.push({
+            type: "iterableForEachToForOf",
+            line: node.loc.start.line,
+          })
+        }
+      }
+    })
+
+  return { modified, changes }
+}

package/tests/cli.test.js

@@ -41,7 +41,7 @@ describe("CLI", () => {
 
     const transformedCode = fs.readFileSync(testFile, "utf8")
     assert.match(transformedCode, /const x = 1/)
-    assert.match(result.stdout, /Summary: 1 file\(s\) upgraded/)
+    assert.match(result.stdout, /✓ 1 file\(s\) upgraded/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -57,7 +57,6 @@ describe("CLI", () => {
     const transformedCode = fs.readFileSync(testFile, "utf8")
     assert.match(transformedCode, /const x = 1/)
     assert.doesNotMatch(transformedCode, /Promise\.try/) // Promise.try not in widely-available
-    assert.match(result.stdout, /widely-available/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -77,7 +76,6 @@ describe("CLI", () => {
     const transformedCode = fs.readFileSync(testFile, "utf8")
     assert.match(transformedCode, /const x = 1/)
     assert.match(transformedCode, /Promise\.try/) // Promise.try in newly-available
-    assert.match(result.stdout, /newly-available/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -108,7 +106,7 @@ describe("CLI", () => {
 
     const fileContent = fs.readFileSync(testFile, "utf8")
     assert.strictEqual(fileContent, originalCode) // File unchanged
-    assert.match(result.stdout, /All files are already modern/)
+    assert.match(result.stdout, /All files are up to date/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -128,8 +126,7 @@ describe("CLI", () => {
     const transformedCode = fs.readFileSync(testFile, "utf8")
     assert.match(transformedCode, /const x = 1/)
     assert.match(result.stdout, /✗/)
-    assert.match(result.stdout, /Changes written to file/)
-    assert.match(result.stdout, /1 file\(s\) upgraded/)
+    assert.match(result.stdout, /Changes have been written/)
     assert.strictEqual(result.status, 1) // Still exit 1 with --check
   })
 
@@ -150,7 +147,6 @@ describe("CLI", () => {
     const transformed2 = fs.readFileSync(file2, "utf8")
     assert.match(transformed1, /const x = 1/)
     assert.match(transformed2, /const y = 2/)
-    assert.match(result.stdout, /Processing 2 file/)
     assert.match(result.stdout, /2 file\(s\) upgraded/)
     assert.strictEqual(result.status, 0)
   })
@@ -172,7 +168,7 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /Processing 1 file/)
+    // Should only process file1 in tempDir, not in node_modules or .git
     assert.strictEqual(result.status, 0)
   })
 
@@ -191,7 +187,6 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /Processing 4 file/)
     assert.match(result.stdout, /4 file\(s\) upgraded/)
     assert.strictEqual(result.status, 0)
   })
@@ -207,7 +202,6 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /Processing 2 file/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -250,7 +244,6 @@ describe("CLI", () => {
     })
 
     assert.match(result.stdout, /var to const/)
-    assert.match(result.stdout, /line/)
     assert.strictEqual(result.status, 1)
   })
 
@@ -268,7 +261,7 @@ describe("CLI", () => {
     const transformed2 = fs.readFileSync(file2, "utf8")
     assert.match(transformed1, /const x = 1/)
     assert.match(transformed2, /const y = 2/)
-    assert.match(result.stdout, /Processing 2 file/)
+    assert.match(result.stdout, /2 file\(s\) upgraded/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -283,7 +276,7 @@ describe("CLI", () => {
 
     const fileContent = fs.readFileSync(testFile, "utf8")
     assert.strictEqual(fileContent, originalCode)
-    assert.match(result.stdout, /All files are already modern/)
+    assert.match(result.stdout, /All files are up to date/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -296,7 +289,7 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /No changes:/)
+    assert.match(result.stdout, /All files are up to date/)
     assert.strictEqual(result.status, 0)
   })
 
@@ -322,7 +315,6 @@ describe("CLI", () => {
     })
 
     assert.match(result.stdout, /var to const/)
-    assert.match(result.stdout, /lines:/)
     assert.strictEqual(result.status, 1)
   })
 
@@ -335,7 +327,7 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stderr, /Error processing/)
+    assert.match(result.stderr, /✗ Error:/)
     assert.strictEqual(result.status, 0) // CLI continues despite errors
   })
 
@@ -352,7 +344,11 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /Processing 2 file/)
+    const file1Content = fs.readFileSync(file1, "utf8")
+    const file2Content = fs.readFileSync(file2, "utf8")
+    assert.match(file1Content, /const x = 1/)
+    assert.match(file2Content, /const y = 2/)
+    assert.match(result.stdout, /2 file\(s\) upgraded/)
     assert.strictEqual(result.status, 0)
   })
 })