esupgrade 2025.20.1 → 2025.21.0

package/.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
           node-version-file: package.json
       - run: npm ci
       - run: node --test --experimental-test-coverage --test-reporter=spec --test-reporter=lcov --test-reporter-destination=stdout --test-reporter-destination=lcov.info
-      - uses: codecov/codecov-action@v6
+      - uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: javascript

package/README.md

@@ -10,6 +10,10 @@
 
 Keeping your JavaScript and TypeScript code up to date with full browser compatibility.
 
+## Sponsors
+
+[![Sponsors](https://django.the-box.sh/sponsors/codingjoe/esupgrade.svg)](https://github.com/sponsors/codingjoe)
+
 ## Usage
 
 esupgrade is safe and meant to be used automatically on your codebase.
@@ -229,12 +233,21 @@ Supports:
 ```diff
 -const budget = 1000000;
 -const maxUsers = 1000000n;
+-const permission = 0o1234567;
+-const mask = 0xabcdef;
+-const flags = 0b1010000111000011;
+-const ratio = 100000.25;
+-const large = 1e100000;
 +const budget = 1_000_000;
 +const maxUsers = 1_000_000n;
++const permission = 0o1_234_567;
++const mask = 0xab_cd_ef;
++const flags = 0b10100001_11000011;
++const ratio = 100_000.25;
++const large = 1e100_000;
 ```
 
-esupgrade transforms decimal integer and bigint literals with at least five digits.
-Fractional, exponential, hexadecimal, octal, binary, and already formatted literals are left unchanged.
+Decimal and octal numerals are grouped by triplets; hex and binary by byte.
 
 #### `Array.slice(0)` → [Array spread [...]][mdn-spread]
 

package/package.json

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

package/src/widelyAvailable/numericSeparators.js

@@ -1,6 +1,33 @@
 import { default as j } from "jscodeshift"
 
-const LARGE_DECIMAL_INTEGER_LITERAL = /^(?<digits>[1-9]\d{4,})(?<suffix>n)?$/
+const MIN_DIGITS_FOR_GROUPING = 5
+const TRANSFORMABLE_DECIMAL_INTEGER_LITERAL = new RegExp(
+  `^(?<digits>[1-9]\\d{${MIN_DIGITS_FOR_GROUPING - 1},})(?<suffix>n)?$`,
+)
+const TRANSFORMABLE_OCTAL_LITERAL =
+  /^(?<prefix>0[oO])(?<digits>[0-7]{4,})(?<suffix>n)?$/
+const TRANSFORMABLE_HEX_LITERAL =
+  /^(?<prefix>0[xX])(?<digits>[0-9a-fA-F]{3,})(?<suffix>n)?$/
+const TRANSFORMABLE_BINARY_LITERAL =
+  /^(?<prefix>0[bB])(?<digits>[01]{9,})(?<suffix>n)?$/
+const FLOAT_LITERAL = /^(?<integer>\d+)\.(?<decimal>\d*)$/
+const EXPONENTIAL_LITERAL =
+  /^(?:(?<mantissaInt>\d+)(?:\.(?<mantissaDec>\d*))?|\.(?<mantissaLeadingDec>\d+))(?<expMarker>[eE])(?<sign>[+-]?)(?<exponent>\d+)$/
+
+/**
+ * Apply numeric separators to digit groups counted from the right.
+ *
+ * @param {string} digits - Digit string without separators.
+ * @param {number} groupSize - Number of characters per group.
+ * @returns {string} Digits with `_` inserted between right-aligned groups.
+ */
+function applyDigitGroupSep(digits, groupSize) {
+  const firstGroupLength = digits.length % groupSize || groupSize
+
+  return digits.length > groupSize
+    ? `${digits.slice(0, firstGroupLength)}_${applyDigitGroupSep(digits.slice(firstGroupLength), groupSize)}`
+    : digits
+}
 
 /**
  * Return a decimal integer literal with numeric separators when applicable.
@@ -8,8 +35,8 @@ const LARGE_DECIMAL_INTEGER_LITERAL = /^(?<digits>[1-9]\d{4,})(?<suffix>n)?$/
  * @param {string} rawLiteral - Raw literal source text.
  * @returns {string | null} Formatted literal or null when no change applies.
  */
-function formatNumericLiteral(rawLiteral) {
-  const match = rawLiteral.match(LARGE_DECIMAL_INTEGER_LITERAL)
+function formatDecimalIntegerLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_DECIMAL_INTEGER_LITERAL)
 
   if (!match?.groups) {
     return null
@@ -17,7 +44,147 @@ function formatNumericLiteral(rawLiteral) {
 
   const { digits, suffix = "" } = match.groups
 
-  return `${digits.replace(/\B(?=(\d{3})+(?!\d))/g, "_")}${suffix}`
+  return `${applyDigitGroupSep(digits, 3)}${suffix}`
+}
+
+/**
+ * Return an octal literal with triplet numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatOctalLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_OCTAL_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  return `${prefix}${applyDigitGroupSep(digits, 3)}${suffix}`
+}
+
+/**
+ * Return a hex literal with byte-level numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatHexLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_HEX_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  // Insert `_` before each group of 2 hex chars counted from the right.
+  return `${prefix}${applyDigitGroupSep(digits, 2)}${suffix}`
+}
+
+/**
+ * Return a binary literal with byte-level numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatBinaryLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_BINARY_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  // Insert `_` before each group of 8 bits counted from the right.
+  return `${prefix}${applyDigitGroupSep(digits, 8)}${suffix}`
+}
+
+/**
+ * Return a float literal with thousands separators on the integer part when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatFloatLiteral(rawLiteral) {
+  const match = rawLiteral.match(FLOAT_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { integer, decimal } = match.groups
+
+  if (integer.length < MIN_DIGITS_FOR_GROUPING) {
+    return null
+  }
+
+  return `${applyDigitGroupSep(integer, 3)}.${decimal}`
+}
+
+/**
+ * Return an exponential literal with thousands separators on large parts when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatExponentialLiteral(rawLiteral) {
+  const match = rawLiteral.match(EXPONENTIAL_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const {
+    mantissaInt = "",
+    mantissaDec,
+    mantissaLeadingDec,
+    expMarker,
+    sign,
+    exponent,
+  } = match.groups
+
+  const formattedMantissaInt =
+    mantissaInt.length >= MIN_DIGITS_FOR_GROUPING
+      ? applyDigitGroupSep(mantissaInt, 3)
+      : mantissaInt
+  const formattedExponent =
+    exponent.length >= MIN_DIGITS_FOR_GROUPING
+      ? applyDigitGroupSep(exponent, 3)
+      : exponent
+
+  if (formattedMantissaInt === mantissaInt && formattedExponent === exponent) {
+    return null
+  }
+
+  const mantissa =
+    typeof mantissaLeadingDec === "string"
+      ? `.${mantissaLeadingDec}`
+      : typeof mantissaDec === "string"
+        ? `${formattedMantissaInt}.${mantissaDec}`
+        : formattedMantissaInt
+
+  return `${mantissa}${expMarker}${sign}${formattedExponent}`
+}
+
+/**
+ * Return a numeric literal with separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatLiteral(rawLiteral) {
+  return (
+    formatDecimalIntegerLiteral(rawLiteral) ??
+    formatOctalLiteral(rawLiteral) ??
+    formatHexLiteral(rawLiteral) ??
+    formatBinaryLiteral(rawLiteral) ??
+    formatFloatLiteral(rawLiteral) ??
+    formatExponentialLiteral(rawLiteral)
+  )
 }
 
 /**
@@ -29,7 +196,7 @@ function formatNumericLiteral(rawLiteral) {
 function updateNumericLiteral(literalNode) {
   const formattedLiteral =
     typeof literalNode.extra?.raw === "string"
-      ? formatNumericLiteral(literalNode.extra.raw)
+      ? formatLiteral(literalNode.extra.raw)
       : null
 
   if (!formattedLiteral) {
@@ -45,7 +212,7 @@ function updateNumericLiteral(literalNode) {
 }
 
 /**
- * Transform large decimal integer literals to use numeric separators.
+ * Transform numeric literals to use numeric separators.
  *
  * @param {import("jscodeshift").Collection} root - The root AST collection.
  * @returns {boolean} True if code was modified.

package/tests/widelyAvailable/numeric-separators.test.js

@@ -40,10 +40,240 @@ suite("widely-available", () => {
       assert(!result.modified)
     })
 
-    test("skip non-decimal literals", () => {
-      const result = transform(
-        `const hexMask = 0xabcdef; const exponent = 1e12; const ratio = 10000.25;`,
-      )
+    test("skip small float and short exponent literals", () => {
+      const result = transform(`const ratio = 1000.25; const exponent = 1e12;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform float literals", () => {
+      const result = transform(`const ratio = 100000.25;`)
+
+      assert.match(result.code, /100_000\.25/)
+      assert(result.modified)
+    })
+
+    test("transform float literals with exact five-digit integer part", () => {
+      const result = transform(`const ratio = 10000.5;`)
+
+      assert.match(result.code, /10_000\.5/)
+      assert(result.modified)
+    })
+
+    test("transform float literals without decimal digits", () => {
+      const result = transform(`const ratio = 10000.;`)
+
+      assert.match(result.code, /10_000\./)
+      assert(result.modified)
+    })
+
+    test("skip float literals with short integer part", () => {
+      const result = transform(`const ratio = 1000.5;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform exponential literals with large exponent", () => {
+      const result = transform(`const n = 1e100000;`)
+
+      assert.match(result.code, /1e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with large mantissa", () => {
+      const result = transform(`const n = 10000e12;`)
+
+      assert.match(result.code, /10_000e12/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with large mantissa and exponent", () => {
+      const result = transform(`const n = 10000e100000;`)
+
+      assert.match(result.code, /10_000e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with float mantissa and large exponent", () => {
+      const result = transform(`const n = 1.5e100000;`)
+
+      assert.match(result.code, /1\.5e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with leading-dot mantissa", () => {
+      const result = transform(`const n = .5e100000;`)
+
+      assert.match(result.code, /\.5e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with trailing-dot mantissa", () => {
+      const result = transform(`const n = 10000.e100000;`)
+
+      assert.match(result.code, /10_000\.e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with signed exponent", () => {
+      const result = transform(`const n = 1e+100000;`)
+
+      assert.match(result.code, /1e\+100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with negative exponent", () => {
+      const result = transform(`const n = 1e-100000;`)
+
+      assert.match(result.code, /1e-100_000/)
+      assert(result.modified)
+    })
+
+    test("transform float literals with leading-zero decimal part", () => {
+      const result = transform(`const ratio = 10000.05;`)
+
+      assert.match(result.code, /10_000\.05/)
+      assert(result.modified)
+    })
+
+    test("transform hex literals", () => {
+      const result = transform(`const mask = 0xabcdef;`)
+
+      assert.match(result.code, /0xab_cd_ef/)
+      assert(result.modified)
+    })
+
+    test("transform octal literals", () => {
+      const result = transform(`const permission = 0o1234567;`)
+
+      assert.match(result.code, /0o1_234_567/)
+      assert(result.modified)
+    })
+
+    test("transform uppercase octal literals", () => {
+      const result = transform(`const permission = 0O1234567;`)
+
+      assert.match(result.code, /0O1_234_567/)
+      assert(result.modified)
+    })
+
+    test("transform octal bigint literals", () => {
+      const result = transform(`const permission = 0o1234567n;`)
+
+      assert.match(result.code, /0o1_234_567n/)
+      assert(result.modified)
+    })
+
+    test("skip short octal literals", () => {
+      const result = transform(`const permission = 0o777;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted octal literals", () => {
+      const result = transform(`const permission = 0o1_234_567;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform uppercase hex literals", () => {
+      const result = transform(`const mask = 0xABCDEF;`)
+
+      assert.match(result.code, /0xAB_CD_EF/)
+      assert(result.modified)
+    })
+
+    test("transform hex literals with odd digit count", () => {
+      const result = transform(`const mask = 0xabcde;`)
+
+      assert.match(result.code, /0xa_bc_de/)
+      assert(result.modified)
+    })
+
+    test("transform hex bigint literals", () => {
+      const result = transform(`const id = 0xabcdefn;`)
+
+      assert.match(result.code, /0xab_cd_efn/)
+      assert(result.modified)
+    })
+
+    test("skip short hex literals", () => {
+      const result = transform(`const byte = 0xff;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted hex literals", () => {
+      const result = transform(`const mask = 0xab_cd_ef;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform binary literals", () => {
+      const result = transform(`const flags = 0b1010000111000011;`)
+
+      assert.match(result.code, /0b10100001_11000011/)
+      assert(result.modified)
+    })
+
+    test("transform binary literals with partial leading byte", () => {
+      const result = transform(`const flags = 0b100000001;`)
+
+      assert.match(result.code, /0b1_00000001/)
+      assert(result.modified)
+    })
+
+    test("transform binary bigint literals", () => {
+      const result = transform(`const flags = 0b1010000111000011n;`)
+
+      assert.match(result.code, /0b10100001_11000011n/)
+      assert(result.modified)
+    })
+
+    test("skip short binary literals", () => {
+      const result = transform(`const byte = 0b11111111;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted binary literals", () => {
+      const result = transform(`const flags = 0b10100001_11000011;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip hex literals with non-byte grouping", () => {
+      const result = transform(`const mask = 0xabc_def;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip binary literals with non-byte grouping", () => {
+      const result = transform(`const flags = 0b1010_0001_1100_0011;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip decimal literals with non-thousand grouping", () => {
+      const result = transform(`const n = 1_0000_000;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip octal literals with non-triplet grouping", () => {
+      const result = transform(`const permission = 0o12_34567;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip float literals with non-standard existing separators", () => {
+      const result = transform(`const ratio = 100_00.25;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip exponential literals with non-standard existing separators", () => {
+      const result = transform(`const n = 1_0000e12;`)
 
       assert(!result.modified)
     })