Added assert.number methods to match assert.number.integer methods

Author: JamesMessinger

README.md

@@ -422,6 +422,49 @@ assert.string.enum("", { None: "none", Some: "some" });           // ❌ Invalid
 This is an alias for [`assert.type.number()`](#assert-number-value-fieldname-defaultvalue)
 
 
+### `assert.number.positive(value, [fieldName], [defaultValue])`
+Asserts that a value is a positive number (greater than zero).
+
+- **value** - The value to check
+- **fieldName** - (optional) The name of the field being assertd. This is used in the error message if the assertion fails.
+- **defaultValue** - (optional) The default value to use if `value` is `undefined`.
+
+```javascript
+import assert from "@jsdevtools/assert";
+
+assert.number.positive(42);              // ✔
+assert.number.positive(12345.678);       // ✔
+assert.number.positive(Infinity);        // ✔
+assert.number.positive(Math.PI);         // ✔
+
+assert.number.positive(0);               // ❌ Invalid value: 0. Expected a positive number.
+assert.number.positive(-42);             // ❌ Invalid value: -42. Expected a positive number.
+assert.number.positive(NaN);             // ❌ Invalid value: NaN. Expected a number.
+```
+
+
+### `assert.number.nonNegative(value, [fieldName], [defaultValue])`
+Asserts that a value is a number that is zero or greater.
+
+- **value** - The value to check
+- **fieldName** - (optional) The name of the field being assertd. This is used in the error message if the assertion fails.
+- **defaultValue** - (optional) The default value to use if `value` is `undefined`.
+
+```javascript
+import assert from "@jsdevtools/assert";
+
+assert.number.nonNegative(0);               // ✔
+assert.number.nonNegative(42);              // ✔
+assert.number.nonNegative(12345.6789);      // ✔
+assert.number.nonNegative(Infinity);        // ✔
+assert.number.nonNegative(Math.PI);         // ✔
+
+assert.number.nonNegative(-42);             // ❌ Invalid value: -42. Expected zero or greater.
+assert.number.nonNegative(-Infinity);       // ❌ Invalid value: -Infinity. Expected zero or greater.
+assert.number.nonNegative(NaN);             // ❌ Invalid value: NaN. Expected a number.
+```
+
+
 ### `assert.number.integer(value, [fieldName], [defaultValue])`
 Asserts that a value is an integer value (positive or negative).
 

src/number.ts

@@ -23,6 +23,26 @@ export interface AssertNumber {
    * Asserts that a value is an integer value (positive or negative).
    */
   integer: AssertInteger;
+
+  /**
+   * Asserts that a value is a positive number value (greater than zero).
+   */
+  positive<T extends number>(value: T | undefined, fieldName?: string, defaultValue?: T): T;
+
+  /**
+   * Asserts that a value is a positive number value (greater than zero).
+   */
+  positive(value: unknown, fieldName?: string, defaultValue?: unknown): number;
+
+  /**
+   * Asserts that a value is a number value that is zero or greater.
+   */
+  nonNegative<T extends number>(value: T | undefined, fieldName?: string, defaultValue?: T): T;
+
+  /**
+   * Asserts that a value is a number value that is zero or greater.
+   */
+  nonNegative(value: unknown, fieldName?: string, defaultValue?: unknown): number;
 }
 
 /**
@@ -67,11 +87,35 @@ export interface AssertInteger {
  */
 // tslint:disable-next-line: variable-name
 export const number = type.number as AssertNumber;
+number.positive = assertPositiveNumber;
+number.nonNegative = assertNonNegativeNumber;
 number.integer = assertInteger as AssertInteger;
 number.integer.positive = assertPositiveInteger;
 number.integer.nonNegative = assertNonNegativeInteger;
 
 
+function assertPositiveNumber(value: number | undefined, fieldName = "value", defaultValue?: number): number {
+  value = type.number(value, fieldName, defaultValue);
+
+  if (value <= 0) {
+    throw ono.range(`Invalid ${fieldName}: ${humanize(value)}. Expected a positive number.`);
+  }
+
+  return value;
+}
+
+
+function assertNonNegativeNumber(value: number | undefined, fieldName = "value", defaultValue?: number): number {
+  value = type.number(value, fieldName, defaultValue);
+
+  if (value < 0) {
+    throw ono.range(`Invalid ${fieldName}: ${humanize(value)}. Expected zero or greater.`);
+  }
+
+  return value;
+}
+
+
 function assertInteger(value: number | undefined, fieldName = "value", defaultValue?: number): number {
   value = type.number(value, fieldName, defaultValue);
 

test/specs/number-non-negative.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { assert } = require("../../lib");
+const { expect } = require("chai");
+
+describe("assert.number.nonNegative()", () => {
+
+  it("should assert zero", () => {
+    expect(assert.number.nonNegative(0)).to.equal(0);
+    expect(assert.number.nonNegative(0.0)).to.equal(0);
+  });
+
+  it("should assert non-negative numbers", () => {
+    expect(assert.number.nonNegative(0)).to.equal(0);
+    expect(assert.number.nonNegative(0.0)).to.equal(0);
+    expect(assert.number.nonNegative(1.0)).to.equal(1);
+    expect(assert.number.nonNegative(1.00001)).to.equal(1.00001);
+    expect(assert.number.nonNegative(4.2)).to.equal(4.2);
+    expect(assert.number.nonNegative(12345.6789)).to.equal(12345.6789);
+    expect(assert.number.nonNegative(Number.MAX_VALUE)).to.equal(Number.MAX_VALUE);
+    expect(assert.number.nonNegative(Math.PI)).to.equal(Math.PI);
+  });
+
+  it("should throw an error for negative numbers", () => {
+    function negative (value) {
+      return () => {
+        assert.number.nonNegative(value);
+      };
+    }
+
+    expect(negative(-1)).to.throw(RangeError, "Invalid value: -1. Expected zero or greater.");
+    expect(negative(Number.MIN_SAFE_INTEGER)).to.throw(RangeError, "Invalid value: -9007199254740991. Expected zero or greater.");
+  });
+
+  it("should throw an error for invalid defaults", () => {
+    function negative (defaultValue) {
+      return () => {
+        assert.number.nonNegative(undefined, "age", defaultValue);
+      };
+    }
+
+    expect(negative(-1)).to.throw(RangeError, "Invalid age: -1. Expected zero or greater.");
+    expect(negative(Number.MIN_SAFE_INTEGER)).to.throw(RangeError, "Invalid age: -9007199254740991. Expected zero or greater.");
+  });
+
+});

test/specs/number-positive.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const { assert } = require("../../lib");
+const { expect } = require("chai");
+
+describe("assert.number.positive()", () => {
+
+  it("should assert positive integers", () => {
+    expect(assert.number.positive(1)).to.equal(1);
+    expect(assert.number.positive(4.2)).to.equal(4.2);
+    expect(assert.number.positive(1234.5678)).to.equal(1234.5678);
+    expect(assert.number.positive(Number.MAX_VALUE)).to.equal(Number.MAX_VALUE);
+    expect(assert.number.positive(Math.PI)).to.equal(Math.PI);
+  });
+
+  it("should throw an error for negative numbers", () => {
+    function negative (value) {
+      return () => {
+        assert.number.positive(value);
+      };
+    }
+
+    expect(negative(0)).to.throw(RangeError, "Invalid value: 0. Expected a positive number.");
+    expect(negative(-1)).to.throw(RangeError, "Invalid value: -1. Expected a positive number.");
+    expect(negative(Number.MIN_SAFE_INTEGER)).to.throw(RangeError, "Invalid value: -9007199254740991. Expected a positive number.");
+  });
+
+  it("should throw an error for invalid defaults", () => {
+    function negative (defaultValue) {
+      return () => {
+        assert.number.positive(undefined, "age", defaultValue);
+      };
+    }
+
+    expect(negative(0)).to.throw(RangeError, "Invalid age: 0. Expected a positive number.");
+    expect(negative(-1)).to.throw(RangeError, "Invalid age: -1. Expected a positive number.");
+    expect(negative(Number.MIN_SAFE_INTEGER)).to.throw(RangeError, "Invalid age: -9007199254740991. Expected a positive number.");
+  });
+
+});