refactor: make number input immutable

src/datatype.ts

@@ -47,32 +47,31 @@ export class Datatype {
 
     options = options ?? {};
 
-    if (typeof options.min === 'undefined') {
-      options.min = 0;
+    let max = 99999;
+    let min = 0;
+    let precision = 1;
+    if (typeof options.min === 'number') {
+      min = options.min;
     }
 
-    if (typeof options.max === 'undefined') {
-      options.max = 99999;
+    if (typeof options.max === 'number') {
+      max = options.max;
     }
 
-    if (typeof options.precision === 'undefined') {
-      options.precision = 1;
+    if (typeof options.precision === 'number') {
+      precision = options.precision;
     }
 
     // Make the range inclusive of the max value
-    let max = options.max;
     if (max >= 0) {
-      max += options.precision;
+      max += precision;
     }
 
     let randomNumber = Math.floor(
-      this.faker.mersenne.rand(
-        max / options.precision,
-        options.min / options.precision
-      )
+      this.faker.mersenne.rand(max / precision, min / precision)
     );
     // Workaround problem in Float point arithmetics for e.g. 6681493 / 0.01
-    randomNumber = randomNumber / (1 / options.precision);
+    randomNumber = randomNumber / (1 / precision);
 
     return randomNumber;
   }

test/datatype.spec.ts

@@ -445,18 +445,27 @@ describe('datatype', () => {
           }
         });
 
-        it('should not modify the input object', () => {
-          const min = 1;
-          const max = 2;
-          const opts = {
-            min: min,
-            max: max,
+        it('should not mutate the input object', () => {
+          const initalMin = 1;
+          const initalPrecision = 1;
+          const initalOtherProperty = 'hello darkness my old friend';
+          const input: {
+            min?: number;
+            max?: number;
+            precision?: number;
+            otherProperty: string;
+          } = {
+            min: initalMin,
+            precision: initalPrecision,
+            otherProperty: initalOtherProperty,
           };
 
-          faker.datatype.number(opts);
+          faker.datatype.number(input);
 
-          expect(opts.min).toBe(min);
-          expect(opts.max).toBe(max);
+          expect(input.min).toBe(initalMin);
+          expect(input.precision).toBe(initalPrecision);
+          expect(input.max).toBe(undefined);
+          expect(input.otherProperty).toBe(initalOtherProperty);
         });
       });