fix: round to correct precision when step uses exponential notation (#8290)

* fix: round to correct precision when step uses exponential notation

* fix: correct significand precision calculation for exponential steps

* refactor: simplify precision calculation for exponents

---------

Co-authored-by: Robert Snow <[email protected]>

Author: lucasweng

packages/@react-stately/utils/src/number.ts

@@ -20,9 +20,18 @@ export function clamp(value: number, min: number = -Infinity, max: number = Infi
 
 export function roundToStepPrecision(value: number, step: number): number {
   let roundedValue = value;
+  let precision = 0;
   let stepString = step.toString();
-  let pointIndex = stepString.indexOf('.');
-  let precision = pointIndex >= 0 ? stepString.length - pointIndex : 0;
+  // Handle negative exponents in exponential notation (e.g., "1e-7" → precision 8)
+  let eIndex = stepString.toLowerCase().indexOf('e-');
+  if (eIndex > 0) {
+    precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + eIndex;
+  } else {
+    let pointIndex = stepString.indexOf('.');
+    if (pointIndex >= 0) {
+      precision = stepString.length - pointIndex;
+    }
+  }
   if (precision > 0) {
     let pow = Math.pow(10, precision);
     roundedValue = Math.round(roundedValue * pow) / pow;

packages/@react-stately/utils/test/number.test.ts

@@ -1,4 +1,4 @@
-import {clamp, snapValueToStep} from '../src/number';
+import {clamp, roundToStepPrecision, snapValueToStep} from '../src/number';
 
 describe('number utils', () => {
   describe('clamp', () => {
@@ -8,6 +8,34 @@ describe('number utils', () => {
     });
   });
 
+  describe('roundToStepPrecision', () => {
+    it('should return the input unchanged for integer steps', () => {
+      expect(roundToStepPrecision(7.123, 1)).toBe(7.123);
+      expect(roundToStepPrecision(5, 10)).toBe(5);
+    });
+    it('should round to the correct decimal places for steps with decimals', () => {
+      expect(roundToStepPrecision(1.24, 0.1)).toBe(1.24);
+      expect(roundToStepPrecision(1.456, 0.01)).toBe(1.456);
+      expect(roundToStepPrecision(1.2345, 0.015)).toBe(1.2345);
+      expect(roundToStepPrecision(1.2345, 0.25)).toBe(1.235);
+      // Should not overcount precision
+      expect(roundToStepPrecision(2.349, 0.100)).toBe(2.35);
+      expect(roundToStepPrecision(2.35, 0.100)).toBe(2.35);
+      // Should handle negative values
+      expect(roundToStepPrecision(-1.456, 0.01)).toBe(-1.456);
+      // Should handle zero value
+      expect(roundToStepPrecision(0, 0.01)).toBe(0);
+    });
+    it('should handle rounding for exponential step values', () => {
+      expect(roundToStepPrecision(0.123456789, 1e-3)).toBe(0.1235);
+      expect(roundToStepPrecision(0.123456789, 1e-7)).toBe(0.12345679);
+      expect(roundToStepPrecision(0.123456789, 1.5e-7)).toBe(0.123456789);
+      expect(roundToStepPrecision(0.123456789, 2.5e-6)).toBe(0.12345679);
+      // Should handle exponential notation steps regardless of e/E case
+      expect(roundToStepPrecision(0.123456789, 1E-8)).toBe(0.123456789);
+    });
+  });
+
   describe('snapValueToStep', () => {
     it('should snap value to nearest step based on min and max', () => {
       expect(snapValueToStep(2, -0.5, 100, 3)).toBe(2.5);