esupgrade 2025.16.0 → 2025.17.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/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
@@ -561,9 +576,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
@@ -804,6 +819,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.17.0",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/widelyAvailable/objectKeysMapToValues.js

@@ -0,0 +1,121 @@
+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((path) => {
+      const node = path.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
+}

package/src/widelyAvailable.js

@@ -20,6 +20,7 @@ export { namedArrowFunctionToNamedFunction } from "./widelyAvailable/namedArrowF
 export { nullishCoalescingOperator } from "./widelyAvailable/nullishCoalescingOperator.js"
 export { objectAssignToSpread } from "./widelyAvailable/objectAssignToSpread.js"
 export { objectKeysForEachToEntries } from "./widelyAvailable/objectKeysForEachToEntries.js"
+export { objectKeysMapToValues } from "./widelyAvailable/objectKeysMapToValues.js"
 export { optionalChaining } from "./widelyAvailable/optionalChaining.js"
 export { promiseToAsyncAwait } from "./widelyAvailable/promiseToAsyncAwait.js"
 export { removeUseStrictFromModules } from "./widelyAvailable/removeUseStrictFromModules.js"

package/tests/widelyAvailable/object-keys-map-to-values.test.js

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict"
+import { describe, suite, test } from "node:test"
+import { transform } from "../../src/index.js"
+
+suite("widely-available", () => {
+  describe("objectKeysMapToValues", () => {
+    test("transform arrow function with expression body", () => {
+      const result = transform(`Object.keys(obj).map(key => obj[key])`)
+
+      assert(result.modified)
+      assert.match(result.code, /Object\.values\(obj\)/)
+      assert.doesNotMatch(result.code, /Object\.keys/)
+    })
+
+    test("transform arrow function with block body and return", () => {
+      const result = transform(`Object.keys(obj).map(key => { return obj[key]; })`)
+
+      assert(result.modified)
+      assert.match(result.code, /Object\.values\(obj\)/)
+    })
+
+    test("transform regular function expression", () => {
+      const result = transform(
+        `Object.keys(obj).map(function(key) { return obj[key]; })`,
+      )
+
+      assert(result.modified)
+      assert.match(result.code, /Object\.values\(obj\)/)
+    })
+
+    test("transform when object is a member expression", () => {
+      const result = transform(
+        `Object.keys(config.options).map(key => config.options[key])`,
+      )
+
+      assert(!result.modified)
+    })
+
+    test("skip when key not used as index", () => {
+      const result = transform(`Object.keys(obj).map(key => key.toUpperCase())`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when accessing different object", () => {
+      const result = transform(`Object.keys(obj).map(key => other[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when callback has multiple parameters", () => {
+      const result = transform(`Object.keys(obj).map((key, index) => obj[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when block body has multiple statements", () => {
+      const result = transform(
+        `Object.keys(obj).map(key => { const v = obj[key]; return v; })`,
+      )
+
+      assert(!result.modified)
+    })
+
+    test("skip when map callback is a reference", () => {
+      const result = transform(`Object.keys(obj).map(getter)`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when Object.keys called with multiple arguments", () => {
+      const result = transform(`Object.keys(obj, extra).map(key => obj[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when map called with thisArg", () => {
+      const result = transform(`Object.keys(obj).map(key => obj[key], ctx)`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when map is not called on Object.keys()", () => {
+      const result = transform(`[1, 2, 3].map(key => obj[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when target object is a function call", () => {
+      const result = transform(`Object.keys(getObj()).map(key => getObj()[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when async arrow function callback", () => {
+      const result = transform(`Object.keys(obj).map(async key => obj[key])`)
+
+      assert(!result.modified)
+    })
+
+    test("skip when generator function callback", () => {
+      const result = transform(
+        `Object.keys(obj).map(function*(key) { return obj[key]; })`,
+      )
+
+      assert(!result.modified)
+    })
+  })
+})