esupgrade 2025.16.0 → 2025.18.0

package/.github/agents/superjoe.agent.md

@@ -12,7 +12,7 @@ description: CodingJoe's digital clone following his coding guidelines and best
 
 You MUST ALWAYS follow the `naming-things` guidelines. Use the following command to access the guidelines:
 ```console
-curl -sSL https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md | cat
+curl -sSL https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md | head -n 500
 ```
 
 You MUST ALWAYS read the `CONTRIBUTING.md` file before planning or writing any code.

package/.github/copilot-instructions.md

@@ -1,15 +1,15 @@
+YOUR PRIORITY IS TO ENSURE THE SAFETY OF ALL TRANSFORMATIONS.
+
 When writing code, you MUST ALWAYS follow the [naming guidelines](https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md).
 
 Usage:
 
 ```console
-curl -sL https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md
+curl -sL https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md | head -n 500
 ```
 
 All code must be fully tested with a 100% coverage. Unreachable code must be removed.
 Follow the [CONTRIBUTING.md](./CONTRIBUTING.md) guidelines for testing and linting.
-The test suite will fail if the line coverage is below 100%.
-The test coverage will be written to stdout when running the tests via `npm test | grep -v '100.00'`.
 
 All transformers must be documented in the README.md.
 

package/.pre-commit-config.yaml

@@ -32,7 +32,7 @@ repos:
       - id: write-good
         args: [--no-passive]
   - repo: https://github.com/pre-commit/mirrors-eslint
-    rev: v10.3.0
+    rev: v10.4.0
     hooks:
       - id: eslint
         args: ["--fix"]

package/README.md

@@ -47,9 +47,9 @@ 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">
+  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/assets/img/baseline-wordmark-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/assets/img/baseline-wordmark.svg">
+  <img alt="Baseline: widely available" src="https://web-platform-dx.github.io/assets/img/baseline-wordmark.svg" height="32" align="right">
 </picture>
 
 ## Browser Support & Baseline
@@ -78,9 +78,9 @@ For more information about Baseline browser support, visit [web.dev/baseline][ba
 ## Transformations
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-widely-word-dark.svg">
-  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-widely-word.svg">
-  <img alt="Baseline: widely available" src="https://web-platform-dx.github.io/web-features/assets/img/baseline-widely-word.svg" height="32" align="right">
+  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/assets/img/baseline-widely-word-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/assets/img/baseline-widely-word.svg">
+  <img alt="Baseline: widely available" src="https://web-platform-dx.github.io/assets/img/baseline-widely-word.svg" height="32" align="right">
 </picture>
 
 ### Widely available
@@ -457,6 +457,21 @@ Transforms when:
 - The first statement in the callback assigns `obj[key]` to a variable
 - The object being accessed matches the object passed to Object.keys()
 
+#### `Object.keys().map()` → [Object.values()][mdn-object-values]
+
+```diff
+-Object.keys(obj).map(key => obj[key])
++Object.values(obj)
+```
+
+Transforms `Object.keys(obj).map(key => obj[key])` patterns to use `Object.values()` directly. This eliminates redundant property lookups and expresses intent more clearly.
+
+Transforms when:
+
+- The callback has exactly one parameter (the key)
+- The callback body returns `obj[key]` (expression or block with a single return statement)
+- The object being accessed matches the object passed to Object.keys()
+
 #### `indexOf()` prefix check → [String.startsWith()][mdn-startswith]
 
 ```diff
@@ -535,6 +550,37 @@ The transformer handles cases where `Array.from(arguments)` has already been con
 
 Note: The `x = x || defaultValue` pattern is NOT transformed as it has different semantics (triggers on any falsy value, instead of `undefined`).
 
+#### Manual property extraction → [Destructuring parameters][mdn-destructuring]
+
+```diff
+-function fn(obj) {
+-  const x = obj.x;
+-  const y = obj.y;
+-  // use x and y
+-}
++function fn({x, y}) {
++  // use x and y
++}
+```
+
+Transforms functions where the body begins by extracting properties from a parameter into object destructuring in the parameter list. Aliased extractions use longhand syntax:
+
+```diff
+-function fn(obj) {
+-  const myX = obj.x;
+-}
++function fn({x: myX}) {
++}
+```
+
+Transforms when:
+
+- The parameter is a simple identifier (not already destructured or a rest parameter)
+- Leading statements are variable declarations extracting non-computed properties from that parameter
+- The original parameter identifier is not referenced after the extraction zone
+
+TypeScript type annotations on the original parameter are preserved on the resulting destructuring pattern.
+
 #### Promise chains → [async/await][mdn-async-await]
 
 ```diff
@@ -561,9 +607,9 @@ Note: The `x = x || defaultValue` pattern is NOT transformed as it has different
 - The expression is a known promise (`fetch()`, `new Promise()`, or promise methods)
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-newly-word-dark.svg">
-  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-newly-word.svg">
-  <img alt="Baseline: Newly available" src="https://web-platform-dx.github.io/web-features/assets/img/baseline-newly-word.svg" height="32" align="right">
+  <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/assets/img/baseline-newly-word-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/assets/img/baseline-newly-word.svg">
+  <img alt="Baseline: Newly available" src="https://web-platform-dx.github.io/assets/img/baseline-newly-word.svg" height="32" align="right">
 </picture>
 
 ### Newly available
@@ -794,6 +840,7 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 [mdn-console]: https://developer.mozilla.org/en-US/docs/Web/API/console
 [mdn-const]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
 [mdn-default-parameters]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters
+[mdn-destructuring]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
 [mdn-endswith]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
 [mdn-exponentiation]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation
 [mdn-find]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
@@ -804,6 +851,7 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 [mdn-let]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let
 [mdn-nullish-coalescing]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing
 [mdn-object-entries]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+[mdn-object-values]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values
 [mdn-promise-try]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/try
 [mdn-rest-parameters]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters
 [mdn-slice]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice

package/package.json

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

package/src/jQuery/nextToNextElementSibling.js

@@ -11,8 +11,7 @@ export function nextToNextElementSibling(root) {
   let modified = false
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       if (!j.MemberExpression.check(node.callee)) return false
       if (!j.Identifier.check(node.callee.property)) return false
       if (node.callee.property.name !== "next") return false

package/src/jQuery/prevToPreviousElementSibling.js

@@ -11,8 +11,7 @@ export function prevToPreviousElementSibling(root) {
   let modified = false
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       if (!j.MemberExpression.check(node.callee)) return false
       if (!j.Identifier.check(node.callee.property)) return false
       if (node.callee.property.name !== "prev") return false

package/src/jQuery/readyToDOMContentLoaded.js

@@ -12,8 +12,7 @@ export function readyToDOMContentLoaded(root) {
     .find(j.CallExpression, {
       callee: { type: "MemberExpression" },
     })
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       const callee = node.callee
       if (!j.Identifier.check(callee.property)) return false
       if (callee.property.name !== "ready") return false

package/src/jQuery/siblingsToSiblingsArray.js

@@ -11,8 +11,7 @@ export function siblingsToSiblingsArray(root) {
   let modified = false
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       if (!j.MemberExpression.check(node.callee)) return false
       if (!j.Identifier.check(node.callee.property)) return false
       if (node.callee.property.name !== "siblings") return false

package/src/types.js

@@ -504,9 +504,9 @@ export class NodeTest {
    */
   hasSideEffects() {
     const paramNames = new Set(
-      this.node.params.flatMap((param) =>
-        Array.from(new NodeTest(param).extractIdentifiersFromPattern()),
-      ),
+      this.node.params.flatMap((param) => [
+        ...new NodeTest(param).extractIdentifiersFromPattern(),
+      ]),
     )
     return this.#hasNodeSideEffects(this.node.body, paramNames)
   }
@@ -1066,8 +1066,7 @@ export function processMultipleDeclarators(root, path) {
  * @param {string} name - Name to check for shadowing
  * @returns {boolean} True if the identifier is shadowed
  */
-export function isShadowed(path, name) {
-  let scope = path.scope
+export function isShadowed({ scope }, name) {
   while (scope) {
     if (scope.getBindings()[name]) {
       return true

package/src/widelyAvailable/argumentsToRestParameters.js

@@ -24,8 +24,7 @@ export function argumentsToRestParameters(root) {
     ...root.find(j.FunctionExpression).paths(),
   ]
 
-  functionNodes.forEach((path) => {
-    const func = path.node
+  functionNodes.forEach(({ node: func }) => {
     if (
       (func.params.length > 0 &&
         j.RestElement.check(func.params[func.params.length - 1])) ||

package/src/widelyAvailable/arrayConcatToSpread.js

@@ -13,9 +13,7 @@ export function arrayConcatToSpread(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check if this is a .concat() call
       if (
         !j.MemberExpression.check(node.callee) ||

package/src/widelyAvailable/arrayFilterToFind.js

@@ -14,9 +14,7 @@ export function arrayFilterToFind(root) {
 
   root
     .find(j.MemberExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Must be computed access: expr[0]
       if (!node.computed) {
         return false

package/src/widelyAvailable/arrayFromForEachToForOf.js

@@ -13,8 +13,7 @@ export function arrayFromForEachToForOf(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       // Check if this is a forEach call
       if (
         !j.MemberExpression.check(node.callee) ||

package/src/widelyAvailable/arraySliceToSpread.js

@@ -13,9 +13,7 @@ export function arraySliceToSpread(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check if this is a .slice() call
       if (
         !j.MemberExpression.check(node.callee) ||

package/src/widelyAvailable/consoleLogToInfo.js

@@ -12,8 +12,7 @@ export function consoleLogToInfo(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       // Check if this is a console.log() call
       if (
         !j.MemberExpression.check(node.callee) ||
@@ -27,9 +26,7 @@ export function consoleLogToInfo(root) {
 
       return true
     })
-    .forEach((path) => {
-      const node = path.node
-
+    .forEach(({ node }) => {
       // Replace the property name from 'log' to 'info'
       node.callee.property.name = "info"
 

package/src/widelyAvailable/constructorToClass.js

@@ -61,8 +61,7 @@ export function constructorToClass(root) {
     // Pattern 1: ConstructorName.prototype.methodName = ...
     root
       .find(j.ExpressionStatement)
-      .filter((path) => {
-        const node = path.node
+      .filter(({ node }) => {
         if (!j.AssignmentExpression.check(node.expression)) {
           return false
         }
@@ -105,8 +104,7 @@ export function constructorToClass(root) {
     // Pattern 2: ConstructorName.prototype = { methodName: function() {...}, ... }
     root
       .find(j.ExpressionStatement)
-      .filter((path) => {
-        const node = path.node
+      .filter(({ node }) => {
         if (!j.AssignmentExpression.check(node.expression)) {
           return false
         }

package/src/widelyAvailable/defaultParameterValues.js

@@ -27,9 +27,7 @@ export function defaultParameterValues(root) {
     ...root.find(j.ArrowFunctionExpression).paths(),
   ]
 
-  functionNodes.forEach((path) => {
-    const func = path.node
-
+  functionNodes.forEach(({ node: func }) => {
     // Skip if function body is not a block statement
     if (!j.BlockStatement.check(func.body)) {
       return

package/src/widelyAvailable/forLoopToForOf.js

@@ -14,9 +14,7 @@ export function forLoopToForOf(root) {
 
   root
     .find(j.ForStatement)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check init: must be let/const i = 0
       if (!j.VariableDeclaration.check(node.init)) {
         return false

package/src/widelyAvailable/globalContextToGlobalThis.js

@@ -14,8 +14,7 @@ export function globalContextToGlobalThis(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       // Check if this is a call to Function constructor
       if (
         !j.Identifier.check(node.callee) ||

package/src/widelyAvailable/indexOfToIncludes.js

@@ -16,9 +16,7 @@ export function indexOfToIncludes(root) {
 
   root
     .find(j.BinaryExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check for comparison operators: !==, ===, >, >=, <, <=
       if (!["!==", "===", ">", ">=", "<", "<="].includes(node.operator)) {
         return false

package/src/widelyAvailable/indexOfToStartsWith.js

@@ -14,9 +14,7 @@ export function indexOfToStartsWith(root) {
 
   root
     .find(j.BinaryExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check for === or !== operators
       if (!["===", "!=="].includes(node.operator)) {
         return false

package/src/widelyAvailable/iterableForEachToForOf.js

@@ -31,8 +31,7 @@ export function iterableForEachToForOf(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
+    .filter(({ node }) => {
       // Check if this is a forEach call
       if (
         !j.MemberExpression.check(node.callee) ||

package/src/widelyAvailable/lastIndexOfToEndsWith.js

@@ -15,9 +15,7 @@ export function lastIndexOfToEndsWith(root) {
 
   root
     .find(j.BinaryExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check for === or !== operators
       if (!["===", "!=="].includes(node.operator)) {
         return false

package/src/widelyAvailable/namedArrowFunctionToNamedFunction.js

@@ -27,9 +27,7 @@ export function namedArrowFunctionToNamedFunction(root) {
 
   root
     .find(j.VariableDeclaration)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Must have exactly one declarator
       if (node.declarations.length !== 1) {
         return false

package/src/widelyAvailable/nullishCoalescingOperator.js

@@ -13,9 +13,7 @@ export function nullishCoalescingOperator(root) {
 
   root
     .find(j.ConditionalExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Test must be a logical AND expression
       if (!j.LogicalExpression.check(node.test) || node.test.operator !== "&&") {
         return false

package/src/widelyAvailable/objectKeysForEachToEntries.js

@@ -15,9 +15,7 @@ export function objectKeysForEachToEntries(root) {
 
   root
     .find(j.CallExpression)
-    .filter((path) => {
-      const node = path.node
-
+    .filter(({ node }) => {
       // Check if this is a forEach call
       if (
         !j.MemberExpression.check(node.callee) ||

package/src/widelyAvailable/objectKeysMapToValues.js

@@ -0,0 +1,119 @@
+import { default as j } from "jscodeshift"
+import { NodeTest } from "../types.js"
+
+/**
+ * Check if a callback expression body returns `targetObject[keyName]`.
+ *
+ * @param {import("ast-types").ASTNode} body - The callback body
+ * @param {string} keyName - The key parameter name
+ * @param {import("ast-types").ASTNode} targetObject - The object to compare against
+ * @returns {boolean} True if the body returns the expected member expression
+ */
+function isValueAccess(body, keyName, targetObject) {
+  switch (body.type) {
+    case "MemberExpression":
+      return (
+        body.computed === true &&
+        j.Identifier.check(body.property) &&
+        body.property.name === keyName &&
+        new NodeTest(body.object).isEqual(targetObject)
+      )
+    case "BlockStatement": {
+      if (body.body.length !== 1) {
+        return false
+      }
+      const stmt = body.body[0]
+      return (
+        j.ReturnStatement.check(stmt) &&
+        stmt.argument !== null &&
+        isValueAccess(stmt.argument, keyName, targetObject)
+      )
+    }
+    default:
+      return false
+  }
+}
+
+/**
+ * Transform Object.keys(obj).map(key => obj[key]) to Object.values(obj).
+ * Converts patterns where Object.keys() is mapped to retrieve values from the same object
+ * to use Object.values() directly.
+ *
+ * @param {import("jscodeshift").Collection} root - The root AST collection
+ * @returns {boolean} True if code was modified
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values
+ */
+export function objectKeysMapToValues(root) {
+  let modified = false
+
+  root
+    .find(j.CallExpression)
+    .filter(({ node }) => {
+      if (
+        !j.MemberExpression.check(node.callee) ||
+        !j.Identifier.check(node.callee.property) ||
+        node.callee.property.name !== "map"
+      ) {
+        return false
+      }
+
+      const object = node.callee.object
+      if (
+        !j.CallExpression.check(object) ||
+        !j.MemberExpression.check(object.callee) ||
+        !j.Identifier.check(object.callee.object) ||
+        object.callee.object.name !== "Object" ||
+        !j.Identifier.check(object.callee.property) ||
+        object.callee.property.name !== "keys"
+      ) {
+        return false
+      }
+
+      if (object.arguments.length !== 1) {
+        return false
+      }
+
+      if (node.arguments.length !== 1) {
+        return false
+      }
+
+      const callback = node.arguments[0]
+      if (
+        !j.ArrowFunctionExpression.check(callback) &&
+        !j.FunctionExpression.check(callback)
+      ) {
+        return false
+      }
+
+      if (callback.async || callback.generator) {
+        return false
+      }
+
+      if (callback.params.length !== 1 || !j.Identifier.check(callback.params[0])) {
+        return false
+      }
+
+      // Only allow plain identifier targets to avoid changing evaluation count
+      // of expressions with side-effects (getters, function calls, etc.)
+      if (!j.Identifier.check(object.arguments[0])) {
+        return false
+      }
+
+      const keyName = callback.params[0].name
+      return isValueAccess(callback.body, keyName, object.arguments[0])
+    })
+    .forEach((path) => {
+      const targetObject = path.node.callee.object.arguments[0]
+
+      j(path).replaceWith(
+        j.callExpression(
+          j.memberExpression(j.identifier("Object"), j.identifier("values"), false),
+          [targetObject],
+        ),
+      )
+
+      modified = true
+    })
+
+  return modified
+}