Rebuild function

Author: devbyray

.prettierrc

@@ -0,0 +1,7 @@
+{
+  "trailingComma": "all",
+  "tabWidth": 4,
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 200
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "is-between-js",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Check if a number is between a minimum or maximum",
   "keywords": [
     "number",
@@ -63,7 +63,9 @@
     ],
     "coveragePathIgnorePatterns": [
       "/node_modules/",
-      "/test/"
+      "/test/",
+      "/package.json",
+      "/package-lock.json"
     ],
     "coverageThreshold": {
       "global": {

src/is-between-js.ts

@@ -1,28 +1,54 @@
 // Import here Polyfills if needed. Recommended core-js (npm i -D core-js)
 // import "core-js/fn/array.find"
 // ...
-export default function isBetween(value: number, min: number, max: number): Boolean {
-  const valueNumber = parseFloat(value.toString())
-  const minNumber = parseFloat(min.toString())
-  const maxNumber = parseFloat(max.toString())
 
-  const equal = valueNumber === minNumber || minNumber === maxNumber
+export class Between {
+  valueNumber: number = 0
+  minNumber: number = 0
+  maxNumber: number = 0
 
-  if (isNaN(valueNumber) || isNaN(minNumber) || isNaN(maxNumber)) {
-    throw new Error('isBetween() expects numerical input.')
+  private toFloat(input: number) {
+    return parseFloat(input.toString())
   }
 
-  if (minNumber > maxNumber) {
-    throw new Error('Not a valid range: ' + maxNumber + ' < ' + minNumber + '.')
+  value(val: number): Between {
+    this.valueNumber = this.toFloat(val)
+    return this
+  }
+  min(val: number): Between {
+    this.minNumber = this.toFloat(val)
+    return this
+  }
+  max(val: number): Between {
+    this.maxNumber = this.toFloat(val)
+    return this
   }
 
-  const inRange = valueNumber > minNumber && valueNumber < maxNumber
-  return equal || inRange
-}
+  private isEqual() {
+    return this.valueNumber === this.minNumber || this.minNumber === this.maxNumber
+  }
+
+  private isRange(): boolean {
+    return this.valueNumber > this.minNumber && this.valueNumber < this.maxNumber
+  }
 
-function isFalsy(input: any): Boolean {
-  return input === null || input === undefined || input.length === 0
+  public calculate(): boolean {
+    if (isNaN(this.valueNumber) || isNaN(this.minNumber) || isNaN(this.maxNumber)) {
+      throw new Error('isBetween() expects numerical input.')
+    }
+
+    if (this.minNumber > this.maxNumber) {
+      throw new Error('Not a valid range: ' + this.maxNumber + ' < ' + this.minNumber + '.')
+    }
+
+    return this.isEqual() || this.isRange()
+  }
+  public calc(): boolean {
+    return this.calculate()
+  }
 }
-function isTruthy(input: any): Boolean {
-  return input !== null || input !== undefined || input.length !== 0
+
+export function between(value: number) {
+  const func = new Between()
+  return func.value(value)
 }

test/is-between-js.test.ts

@@ -1,24 +1,59 @@
-import isBetween from '../src/is-between-js'
+import { between } from '../src/is-between-js'
 
 /**
  * Dummy test
  */
 describe('isBetween test', () => {
   it('works if isBetween is truthy', () => {
-    expect(isBetween).toBeDefined()
+    expect(between).toBeDefined()
   })
 
   it('isBetween returns true', () => {
-    expect(isBetween(10, 0, 100)).toBe(true)
-    expect(isBetween(1, 0, 10)).toBe(true)
-    expect(isBetween(-5, -10, 10)).toBe(true)
-    expect(isBetween(1.2, 0, 2)).toBe(true)
-    expect(isBetween(3.52, 3.52, 3.53)).toBe(true)
+    expect(
+      between(10)
+        .min(0)
+        .max(100)
+        .calc()
+    ).toBe(true)
+    expect(
+      between(1)
+        .min(0)
+        .max(10)
+        .calc()
+    ).toBe(true)
+    expect(
+      between(-5)
+        .min(-10)
+        .max(10)
+        .calc()
+    ).toBe(true)
+    expect(
+      between(1.2)
+        .min(0)
+        .max(2)
+        .calc()
+    ).toBe(true)
+    expect(
+      between(3.52)
+        .min(3.52)
+        .max(3.53)
+        .calc()
+    ).toBe(true)
   })
   it('isBetween returns false', () => {
-    expect(isBetween(10, 0, 9)).toBe(false)
+    expect(
+      between(10)
+        .min(0)
+        .max(9)
+        .calc()
+    ).toBe(false)
   })
   it('isBetween returns error', () => {
-    expect(() => isBetween(10, 15, 9)).toThrow()
+    expect(() =>
+      between(10)
+        .min(15)
+        .max(9)
+        .calc()
+    ).toThrow()
   })
 })