esupgrade 2025.2.0 → 2025.2.1

package/package.json

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

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)
         }
       }
 

package/tests/widelyAvailable.test.js

@@ -480,6 +480,83 @@ var x = 1;`
       assert.strictEqual(result.modified, true)
       assert.match(result.code, /`/)
     })
+
+    test("numeric addition followed by string concatenation", () => {
+      const input = `cal_box.style.left = findPosX(cal_link) + 17 + 'px';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      // Should treat (findPosX(cal_link) + 17) as a single numeric expression
+      assert.match(result.code, /`\$\{findPosX\(cal_link\) \+ 17\}px`/)
+    })
+
+    test("multiple numeric additions followed by string concatenation", () => {
+      const input = `const result = a + b + c + 'd';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      // Should treat (a + b + c) as a single numeric expression
+      assert.match(result.code, /`\$\{a \+ b \+ c\}d`/)
+    })
+
+    test("string concatenation followed by numeric addition", () => {
+      const input = `const result = 'Value: ' + x + y;`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      // After first string, all subsequent + are string concatenation
+      assert.match(result.code, /`Value: \$\{x\}\$\{y\}`/)
+    })
+
+    test("numeric addition in middle of string concatenations", () => {
+      const input = `const result = 'start' + (a + b) + 'end';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      // Parenthesized numeric expression should be preserved
+      // jscodeshift may add parentheses around binary expressions in template literals
+      assert.match(result.code, /`start\$\{(\()?a \+ b(\))?\}end`/)
+    })
+
+    test("consecutive string literals should be merged", () => {
+      const input = `const msg = 'Hello' + ' ' + 'world';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`Hello world`/)
+    })
+
+    test("string literal followed by non-binary expression", () => {
+      const input = `const msg = 'Value: ' + getValue();`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`Value: \$\{getValue\(\)\}`/)
+    })
+
+    test("expression followed by string literal", () => {
+      const input = `const msg = getValue() + ' is the value';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`\$\{getValue\(\)\} is the value`/)
+    })
+
+    test("non-binary expression in the middle", () => {
+      const input = `const msg = 'start' + getValue() + 'end';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`start\$\{getValue\(\)\}end`/)
+    })
   })
 
   describe("object spread", () => {