Change is.number()

- This will be incompatible with previous usage so I'll have to increment the major version number.
- still needs testing
- is.number() is now only true for real numbers
- removed is.___ and added is.infinite() and is.nan()
- is().type is still "number" for +/-Infinity and NaN
- changed Type .object and .primitive to boolean

Author: wizard04wsu

README.md

@@ -21,41 +21,33 @@ Parameters:
 Return value:
 - A [Type](#the-type-class) object.
 
-### The Type class
+### Type objects
 
-The **Type** class extends the **String** class. In addition to storing a type name, its properties reveal whether the tested value was an object or a primitive.
+In addition to storing a type name, a **Type** object's properties reveal whether the tested value was an object or a primitive.
 
-Syntax:
-> `new Type(typeName)`  
-> `new Type(typeName, objectType)`
-
-Parameters:
-- ***typeName*** - (string)
-- ***objectType*** - (string) The object name used by `Object.prototype.toString()`. Include this for object types. Do not include this for primitive types.
-
-| Property | Type | Description |
-| --- | --- | --- |
-| .**type** | string | The type name (`typeName`). This is also the instance's primitive value. |
-| .**objectType** | string | The object name used by `Object.prototype.toString()`. |
-| .**primitive** | string | For primitive types, this property is set to `typeName`. Otherwise, it's undefined. |
-| .**object** | string | For object types, this property is set to `typeName`. Otherwise, it's undefined. |
+| Property        | Type   | Description
+| - | - | -
+| .**type**       | string | The type name returned by the `typeof` operator.
+| .**objectType** | string | The object name used by `Object.prototype.toString()`. Undefined for primitive types.
+| .**primitive**  | string | True for primitive types.
+| .**object**     | string | True for object types.
 
 ### Example
 
 ```
 is(2).type;	// "number"
-is(2)+""	// "number"
+is(2).toString()	// "number"
 is(2) == "number";	//true
-is(2).primitive === "number";	// true
-is(2).object === "number";	// false
+is(2).primitive;	// true
+is(2).object;	// undefined
 is(2).objectType;	// undefined
 
 let o = new Number(2);
 is(o).type;	// "number"
-is(o)+""	// "number"
+is(o).toString()	// "number"
 is(o) == "number";	//true
-is(o).primitive === "number";	// false
-is(o).object === "number";	// true
+is(o).primitive;	// undefined
+is(o).object;	// true
 is(o).objectType;	// "Number"
 ```
 
@@ -72,10 +64,11 @@ For each of the type-testing methods, the only parameter is the item to be teste
 **is.undefined()**  
 **is.null()**  
 
-**is.number()**  
-**is.number.real()** - This is most likely what you actually want to use when testing for a number.  
-**is.number.infinite()**  
-**is.number.NaN()** - Note that JavaScript doesn't correctly treat all undefined forms as `NaN` (e.g., `1/0` and `0**0`).  
+**is.number()** - A real number.  
+**is.infinite()** \*  
+**is.nan()** \*  
+
+\* Note that JavaScript doesn't correctly treat all undefined forms as `NaN`. For example, `1/0` and `0**0` are undefined forms, but JavaScript treats them as `Infinity`.  
 
 **is.bigint()**  
 **is.boolean()**  

isType.mjs

@@ -1,4 +1,9 @@
 
+const Object = globalThis["Object"];
+const String = globalThis["String"];
+const Number = globalThis["Number"];
+const Boolean = globalThis["Boolean"];
+
 class Type extends String {
 	/**
 	 * @constructor
@@ -8,21 +13,24 @@ class Type extends String {
 	constructor(typeName, objectType){
 		if(!(typeof typeName === "string" || typeName instanceof String))
 			throw new TypeError("'typeName' must be a string");
+		if(typeName == "")
+			throw new RangeError("'typeName' cannot be an empty string");
 		typeName = String(typeName);
 		if(objectType){
 			if(!(typeof objectType === "string" || objectType instanceof String))
 				throw new TypeError("'objectType' must be a string");
 			objectType = String(objectType);
 		}
 
-		super(typeName);
+		super();
 
+		this.type = typeName;
 		if(objectType){
-			this.type = this.object = typeName;
 			this.objectType = objectType;
+			this.object = true;
 		}
 		else{
-			this.type = this.primitive = typeName;
+			this.primitive = true;
 		}
 	}
 }
@@ -74,9 +82,10 @@ for(const type of typeofTypes){
 	is[type] = (v)=>(is(v).type === type);
 }
 
-is.number.real = (v)=>(is.number(v) && Number.isFinite(1*v));
-is.number.infinite = (v)=>(is.number(v) && !Number.isFinite(1*v) && !Number.isNaN(1*v));
-is.number.NaN = (v)=>(is.number(v) && Number.isNaN(1*v));	//Note that JavaScript doesn't correctly treat all undefined forms as NaN (e.g., 1/0 and 0**0).
+const isNumberish = is.number;
+is.number = (v)=>(isNumberish(v) && Number.isFinite(v));
+is.infinite = (v)=>(isNumberish(v) && !Number.isFinite(v) && !Number.isNaN(v));
+is.nan = (v)=>(isNumberish(v) && Number.isNaN(v));	//Note that JavaScript doesn't correctly treat all undefined forms as NaN (e.g., 1/0 and 0**0 are undefined forms, but JavaScript treats them as Infinity).
 
 const otherCommonTypes = [
 	"Error",

test/test.js

@@ -75,25 +75,19 @@ console.group("is.___()");
 
 	testIsType(is.number(5), true);
 	testIsType(is.number(new Number()), true);
-	testIsType(is.number.real(5), true);
-	testIsType(is.number.real(new Number()), true);
-	testIsType(is.number.real(1/0), false);
-	testIsType(is.number.real(NaN), false);
-	testIsType(is.number.real("5"), false);
-	testIsType(is.number(1/0), true);
-	testIsType(is.number(new Number(1/0)), true);
-	testIsType(is.number.infinite(1/0), true);
-	testIsType(is.number.infinite(new Number(1/0)), true);
-	testIsType(is.number.infinite(5), false);
-	testIsType(is.number.infinite(NaN), false);
-	testIsType(is.number.infinite("Infinity"), false);
-	testIsType(is.number(NaN), true);
-	testIsType(is.number(new Number(NaN)), true);
-	testIsType(is.number.NaN(NaN), true);
-	testIsType(is.number.NaN(new Number(NaN)), true);
-	testIsType(is.number.NaN(5), false);
-	testIsType(is.number.NaN(1/0), false);
-	testIsType(is.number.NaN("NaN"), false);
+	testIsType(is.number(1/0), false);
+	testIsType(is.number(NaN), false);
+	testIsType(is.number("5"), false);
+	testIsType(is.infinite(1/0), true);
+	testIsType(is.infinite(new Number(1/0)), true);
+	testIsType(is.infinite(5), false);
+	testIsType(is.infinite(NaN), false);
+	testIsType(is.infinite("Infinity"), false);
+	testIsType(is.nan(NaN), true);
+	testIsType(is.nan(new Number(NaN)), true);
+	testIsType(is.nan(5), false);
+	testIsType(is.nan(1/0), false);
+	testIsType(is.nan("NaN"), false);
 	testIsType(is.number(""), false);
 	testIsType(is.number(new Date()), false);
 	testIsType(is.number(1*(new Date())), true);