From 1284da085f3cad6e1d02fe0ac1bb835293d581dd Mon Sep 17 00:00:00 2001
From: Eugene <63408919+eugene-mohc@users.noreply.github.com>
Date: Fri, 14 Jul 2023 23:26:30 +0100
Subject: [PATCH] Add `is.positiveNumber` and `is.negativeNumber` (#184)

---
 readme.md       |  8 ++++++
 source/index.ts | 11 +++++++
 test/test.ts    | 76 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 95 insertions(+)

diff --git a/readme.md b/readme.md
index a517379..fc451a3 100644
--- a/readme.md
+++ b/readme.md
@@ -410,6 +410,14 @@ function foo() {
 foo();
 ```
 
+#### .positiveNumber(value)
+
+Check if `value` is a number and is more than 0.
+
+#### .negativeNumber(value)
+
+Check if `value` is a number and is less than 0.
+
 ##### .inRange(value, range)
 
 Check if `value` (number) is in the given `range`. The range is an array of two values, lower bound and upper bound, in no specific order.
diff --git a/source/index.ts b/source/index.ts
index 7312deb..4612504 100644
--- a/source/index.ts
+++ b/source/index.ts
@@ -167,6 +167,10 @@ is.string = isOfType<string>('string');
 const isNumberType = isOfType<number>('number');
 is.number = (value: unknown): value is number => isNumberType(value) && !is.nan(value);
 
+is.positiveNumber = (value: unknown): value is number => is.number(value) && value > 0;
+
+is.negativeNumber = (value: unknown): value is number => is.number(value) && value < 0;
+
 is.bigint = isOfType<bigint>('bigint');
 
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -498,6 +502,9 @@ export const enum AssertionTypeDescription {
 	evenInteger = 'even integer',
 	oddInteger = 'odd integer',
 
+	positiveNumber = 'positive number',
+	negativeNumber = 'negative number',
+
 	directInstanceOf = 'T',
 	inRange = 'in range',
 
@@ -511,6 +518,8 @@ type Assert = {
 	undefined: (value: unknown) => asserts value is undefined;
 	string: (value: unknown) => asserts value is string;
 	number: (value: unknown) => asserts value is number;
+	positiveNumber: (value: unknown) => asserts value is number;
+	negativeNumber: (value: unknown) => asserts value is number;
 	bigint: (value: unknown) => asserts value is bigint;
 	// eslint-disable-next-line @typescript-eslint/ban-types
 	function_: (value: unknown) => asserts value is Function;
@@ -609,6 +618,8 @@ export const assert: Assert = {
 	undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), 'undefined', value),
 	string: (value: unknown): asserts value is string => assertType(is.string(value), 'string', value),
 	number: (value: unknown): asserts value is number => assertType(is.number(value), 'number', value),
+	positiveNumber: (value: unknown): asserts value is number => assertType(is.positiveNumber(value), AssertionTypeDescription.positiveNumber, value),
+	negativeNumber: (value: unknown): asserts value is number => assertType(is.negativeNumber(value), AssertionTypeDescription.negativeNumber, value),
 	bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), 'bigint', value),
 	// eslint-disable-next-line @typescript-eslint/ban-types
 	function_: (value: unknown): asserts value is Function => assertType(is.function_(value), 'Function', value),
diff --git a/test/test.ts b/test/test.ts
index e405325..d94fe39 100644
--- a/test/test.ts
+++ b/test/test.ts
@@ -645,6 +645,82 @@ test('is.number', t => {
 	testType(t, 'number', ['integer', 'safeInteger', 'infinite']);
 });
 
+test('is.positiveNumber', t => {
+	t.true(is.positiveNumber(6));
+	t.true(is.positiveNumber(1.4));
+	t.true(is.positiveNumber(Number.POSITIVE_INFINITY));
+
+	t.notThrows(() => {
+		assert.positiveNumber(6);
+	});
+	t.notThrows(() => {
+		assert.positiveNumber(1.4);
+	});
+	t.notThrows(() => {
+		assert.positiveNumber(Number.POSITIVE_INFINITY);
+	});
+
+	t.false(is.positiveNumber(0));
+	t.false(is.positiveNumber(-0));
+	t.false(is.positiveNumber(-6));
+	t.false(is.positiveNumber(-1.4));
+	t.false(is.positiveNumber(Number.NEGATIVE_INFINITY));
+
+	t.throws(() => {
+		assert.positiveNumber(0);
+	});
+	t.throws(() => {
+		assert.positiveNumber(-0);
+	});
+	t.throws(() => {
+		assert.positiveNumber(-6);
+	});
+	t.throws(() => {
+		assert.positiveNumber(-1.4);
+	});
+	t.throws(() => {
+		assert.positiveNumber(Number.NEGATIVE_INFINITY);
+	});
+});
+
+test('is.negativeNumber', t => {
+	t.true(is.negativeNumber(-6));
+	t.true(is.negativeNumber(-1.4));
+	t.true(is.negativeNumber(Number.NEGATIVE_INFINITY));
+
+	t.notThrows(() => {
+		assert.negativeNumber(-6);
+	});
+	t.notThrows(() => {
+		assert.negativeNumber(-1.4);
+	});
+	t.notThrows(() => {
+		assert.negativeNumber(Number.NEGATIVE_INFINITY);
+	});
+
+	t.false(is.negativeNumber(0));
+	t.false(is.negativeNumber(-0));
+	t.false(is.negativeNumber(6));
+	t.false(is.negativeNumber(1.4));
+	t.false(is.negativeNumber(Number.POSITIVE_INFINITY));
+
+	t.throws(() => {
+		assert.negativeNumber(0);
+	});
+	t.throws(() => {
+		assert.negativeNumber(-0);
+	});
+	t.throws(() => {
+		assert.negativeNumber(6);
+	});
+	t.throws(() => {
+		assert.negativeNumber(1.4);
+	});
+	t.throws(() => {
+		assert.negativeNumber(Number.POSITIVE_INFINITY);
+	});
+});
+
 test('is.bigint', t => {
 	testType(t, 'bigint');
 });