GreaterThan / LessThan / GreaterThanOrEqual / LessThanOrEqual: Fix behavior with the number type

source/greater-than-or-equal.d.ts

@@ -16,9 +16,25 @@ type B = GreaterThanOrEqual<1, 1>;
 type C = GreaterThanOrEqual<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+type A = GreaterThanOrEqual<number, 1>;
+//=> boolean
+
+type B = GreaterThanOrEqual<1, number>;
+//=> boolean
+
+type C = GreaterThanOrEqual<number, number>;
+//=> boolean
+```
 */
 export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
+	? boolean
 	: A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? A extends B

source/greater-than.d.ts

@@ -20,12 +20,28 @@ type B = GreaterThan<1, 1>;
 type C = GreaterThan<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+type A = GreaterThan<number, 1>;
+//=> boolean
+
+type B = GreaterThan<1, number>;
+//=> boolean
+
+type C = GreaterThan<number, number>;
+//=> boolean
+```
 */
 export type GreaterThan<A extends number, B extends number> =
 	A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? number extends A | B
-				? never
+				? boolean
 				: [
 					IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
 					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,

source/less-than-or-equal.d.ts

@@ -16,9 +16,28 @@ type B = LessThanOrEqual<1, 1>;
 type C = LessThanOrEqual<1, 5>;
 //=> true
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+type A = LessThanOrEqual<number, 1>;
+//=> boolean
+
+type B = LessThanOrEqual<1, number>;
+//=> boolean
+
+type C = LessThanOrEqual<number, number>;
+//=> boolean
+```
 */
-export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThan<A, B> extends true ? false : true;
+export type LessThanOrEqual<A extends number, B extends number> =
+	GreaterThan<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen
 
 export {};

source/less-than.d.ts

@@ -16,10 +16,25 @@ type B = LessThan<1, 1>;
 type C = LessThan<1, 5>;
 //=> true
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<number, 1>;
+//=> boolean
+
+type B = LessThan<1, number>;
+//=> boolean
+
+type C = LessThan<number, number>;
+//=> boolean
+```
 */
-export type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends infer Result
+export type LessThan<A extends number, B extends number> =
+	GreaterThanOrEqual<A, B> extends infer Result
 		? Result extends true
 			? false
 			: true

test-d/greater-than-or-equal.ts

@@ -11,7 +11,6 @@ expectType<GreaterThanOrEqual<10, -2>>(true);
 expectType<GreaterThanOrEqual<2, 2>>(true);
 expectType<GreaterThanOrEqual<-2, -2>>(true);
 expectType<GreaterThanOrEqual<-2, -3>>(true);
-expectType<GreaterThanOrEqual<-2, number>>(never);
 
 // === unions ===
 expectType<GreaterThanOrEqual<100 | 200, 50>>(true);
@@ -37,3 +36,8 @@ expectType<GreaterThanOrEqual<-999, NegativeInfinity>>(true);
 expectType<GreaterThanOrEqual<PositiveInfinity, PositiveInfinity>>(true);
 expectType<GreaterThanOrEqual<NegativeInfinity, NegativeInfinity>>(true);
 expectType<GreaterThanOrEqual<PositiveInfinity, NegativeInfinity>>(true);
+
+// Non-literal `number`
+expectType<GreaterThanOrEqual<number, number>>({} as boolean);
+expectType<GreaterThanOrEqual<number, 1>>({} as boolean);
+expectType<GreaterThanOrEqual<1, number>>({} as boolean);

test-d/greater-than.ts

@@ -11,7 +11,6 @@ expectType<GreaterThan<10, -2>>(true);
 expectType<GreaterThan<2, 2>>(false);
 expectType<GreaterThan<-2, -2>>(false);
 expectType<GreaterThan<-2, -3>>(true);
-expectType<GreaterThan<-2, number>>(never);
 
 // === unions ===
 expectType<GreaterThan<100 | 200, 50>>(true);
@@ -35,3 +34,8 @@ expectType<GreaterThan<-999, NegativeInfinity>>(true);
 expectType<GreaterThan<PositiveInfinity, PositiveInfinity>>(false);
 expectType<GreaterThan<NegativeInfinity, NegativeInfinity>>(false);
 expectType<GreaterThan<PositiveInfinity, NegativeInfinity>>(true);
+
+// Non-literal `number`
+expectType<GreaterThan<number, number>>({} as boolean);
+expectType<GreaterThan<number, 1>>({} as boolean);
+expectType<GreaterThan<1, number>>({} as boolean);

test-d/less-than-or-equal.ts

@@ -11,7 +11,6 @@ expectType<LessThanOrEqual<10, -2>>(false);
 expectType<LessThanOrEqual<2, 2>>(true);
 expectType<LessThanOrEqual<-2, -2>>(true);
 expectType<LessThanOrEqual<-2, -3>>(false);
-expectType<LessThanOrEqual<-2, number>>(never);
 expectType<LessThanOrEqual<PositiveInfinity, -999>>(false);
 expectType<LessThanOrEqual<PositiveInfinity, 999>>(false);
 expectType<LessThanOrEqual<999, PositiveInfinity>>(true);
@@ -20,3 +19,8 @@ expectType<LessThanOrEqual<-999, NegativeInfinity>>(false);
 expectType<LessThanOrEqual<PositiveInfinity, PositiveInfinity>>(true);
 expectType<LessThanOrEqual<NegativeInfinity, NegativeInfinity>>(true);
 expectType<LessThanOrEqual<PositiveInfinity, NegativeInfinity>>(false);
+
+// Non-literal `number`
+expectType<LessThanOrEqual<number, number>>({} as boolean);
+expectType<LessThanOrEqual<number, 1>>({} as boolean);
+expectType<LessThanOrEqual<1, number>>({} as boolean);

test-d/less-than.ts

@@ -11,7 +11,6 @@ expectType<LessThan<10, -2>>(false);
 expectType<LessThan<2, 2>>(false);
 expectType<LessThan<-2, -2>>(false);
 expectType<LessThan<-2, -3>>(false);
-expectType<LessThan<-2, number>>(never);
 
 // === unions ===
 expectType<LessThan<10, 50 | 100>>(true);
@@ -36,3 +35,8 @@ expectType<LessThan<-999, NegativeInfinity>>(false);
 expectType<LessThan<PositiveInfinity, PositiveInfinity>>(false);
 expectType<LessThan<NegativeInfinity, NegativeInfinity>>(false);
 expectType<LessThan<PositiveInfinity, NegativeInfinity>>(false);
+
+// Non-literal `number`
+expectType<LessThan<number, number>>({} as boolean);
+expectType<LessThan<number, 1>>({} as boolean);
+expectType<LessThan<1, number>>({} as boolean);