fix: improve string validation to reject partial numeric strings

- Change from parseFloat() to Number() for string input validation
- Now properly throws HyperMathError for strings like "3.14abc" instead of parsing as 3.14
- Add comprehensive tests for processInput() method (10+ new test cases)
- Add tests for formatResult() method
- Update README and CHANGELOG to reflect validation behavior
- Test suite now includes 62 tests (all passing)

Author: dinoknowsbetter

CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Fixed
+- 🐛 **String validation**: Changed from `parseFloat()` to `Number()` for string input validation to properly reject strings with trailing non-numeric characters (e.g., `"3.14abc"` now throws `HyperMathError` instead of being parsed as `3.14`)
+
+### Changed
+- 📝 **Documentation**: Updated README to clarify that string validation uses `Number()` and rejects partial numeric strings
+
+### Testing
+- ✅ Added comprehensive tests for `processInput()` method (10+ new test cases)
+- ✅ Added comprehensive tests for `formatResult()` method
+- ✅ Test suite now includes 62 tests (up from 52)
+
 ## [0.1.0] - 2025-11-04
 
 ### ⚠️ BREAKING CHANGES

README.md

@@ -189,7 +189,7 @@ See [CHANGELOG.md](CHANGELOG.md) for complete migration guide.
 - **Edge cases**:
   - **Division by zero**: Throws `DivisionByZeroError` instead of returning 0
   - **Invalid inputs**: Any null, undefined, or non-numeric string values will throw `HyperMathError`
-  - **String parsing**: String inputs are parsed using `parseFloat()`, so partial numeric strings like "123abc" will parse as 123
+  - **String parsing**: String inputs are validated using `Number()` to ensure the entire string is numeric. Strings with trailing non-numeric characters (e.g., `"123abc"`) will throw `HyperMathError`
 - **Type safety**: TypeScript users benefit from full type definitions and the custom `HyperMathError` class for better error handling
 
 ## Support

src/lib/hypermath.spec.ts

@@ -317,4 +317,107 @@ describe('HyperMath', () => {
       expect(HyperMath.formatNumber(2.224)).toBe(2.22);
     });
   });
+describe('HyperMath.processInput', () => {
+  // Valid numbers
+  it('should return the same number for valid number input', () => {
+    expect((HyperMath as any).processInput(42)).toBe(42);
+    expect((HyperMath as any).processInput(-3.14)).toBe(-3.14);
+    expect((HyperMath as any).processInput(0)).toBe(0);
+  });
+
+  // Valid strings
+  it('should parse valid numeric strings', () => {
+    expect((HyperMath as any).processInput('42')).toBe(42);
+    expect((HyperMath as any).processInput('  -3.14  ')).toBe(-3.14);
+    expect((HyperMath as any).processInput('0')).toBe(0);
+    expect((HyperMath as any).processInput('2.5')).toBe(2.5);
+    expect((HyperMath as any).processInput('1.63575')).toBe(1.63575);
+  });
+
+  // Empty string
+  it('should throw HyperMathError for empty string', () => {
+    expect(() => (HyperMath as any).processInput('')).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput('   ')).toThrow(
+      HyperMathError,
+    );
+  });
+
+  // Invalid strings
+  it('should throw HyperMathError for non-numeric strings', () => {
+    expect(() => (HyperMath as any).processInput('abc')).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).processInput('3.14abc')).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).processInput('NaN')).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).processInput('Infinity')).toThrow(
+      HyperMathError,
+    );
+  });
+
+  // Null and undefined
+  it('should throw HyperMathError for null or undefined', () => {
+    expect(() => (HyperMath as any).processInput(null)).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput(undefined)).toThrow(
+      HyperMathError,
+    );
+  });
+
+  // NaN and Infinity
+  it('should throw HyperMathError for NaN and Infinity number inputs', () => {
+    expect(() => (HyperMath as any).processInput(NaN)).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput(Infinity)).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).processInput(-Infinity)).toThrow(
+      HyperMathError,
+    );
+  });
+
+  // Unsupported types
+  it('should throw HyperMathError for unsupported types', () => {
+    expect(() => (HyperMath as any).processInput({})).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput([])).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput(true)).toThrow(HyperMathError);
+    expect(() => (HyperMath as any).processInput(Symbol('sym'))).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).processInput(() => 1)).toThrow(
+      HyperMathError,
+    );
+  });
+});
+describe('HyperMath.formatResult', () => {
+  // Valid finite numbers
+  it('should format a number to 2 decimal places', () => {
+    expect((HyperMath as any).formatResult(3.14159)).toBe(3.14);
+    expect((HyperMath as any).formatResult(5.1)).toBe(5.1);
+    expect((HyperMath as any).formatResult(7)).toBe(7);
+    expect((HyperMath as any).formatResult(-2.567)).toBe(-2.57);
+    expect((HyperMath as any).formatResult(-0.1)).toBe(-0.1);
+    expect((HyperMath as any).formatResult(0.001)).toBe(0);
+    expect((HyperMath as any).formatResult(0.009)).toBe(0.01);
+    expect((HyperMath as any).formatResult(123456789.999)).toBe(123456790);
+    expect((HyperMath as any).formatResult(1.126)).toBe(1.13);
+    expect((HyperMath as any).formatResult(2.224)).toBe(2.22);
+    expect((HyperMath as any).formatResult(0)).toBe(0);
+  });
+
+  // Non-finite numbers
+  it('should throw HyperMathError for NaN', () => {
+    expect(() => (HyperMath as any).formatResult(NaN)).toThrow(HyperMathError);
+  });
+
+  it('should throw HyperMathError for Infinity', () => {
+    expect(() => (HyperMath as any).formatResult(Infinity)).toThrow(
+      HyperMathError,
+    );
+    expect(() => (HyperMath as any).formatResult(-Infinity)).toThrow(
+      HyperMathError,
+    );
+  });
+});
 });

src/lib/hypermath.ts

@@ -60,7 +60,10 @@ export class HyperMath {
         throw new HyperMathError('Invalid input: empty string');
       }
 
-      const parsedNumber = parseFloat(trimmedValue);
+      // Use Number() instead of parseFloat() to ensure the entire string is valid
+      // Number() returns NaN for strings with trailing non-numeric characters
+      // while parseFloat() would parse '3.14abc' as 3.14
+      const parsedNumber = Number(trimmedValue);
 
       // Check if parsing was successful and result is finite
       if (!Number.isFinite(parsedNumber)) {