- rewrite Type class, update is() accordingly

- add types to test
- update README
- update test cases

Author: wizard04wsu

README.md

@@ -30,29 +30,32 @@ Syntax:
 
 Parameters:
 - ***typeName*** - (string)
-- ***isPrimitive*** - (boolean) Optional.
+- ***objectType*** - (string) Optional. The object name used by `Object.prototype.toString()`. Pass this argument for object types only.
 
 | Property | Type | Description |
 | --- | --- | --- |
-| .**type** | string | The type name. This is equivalent to the class's string value. |
-| .**primitive** | string | If the `isPrimitive` argument was truthy when constructed, this property was set to the type name. Otherwise, it's undefined. |
-| .**object** | string | If the `isPrimitive` argument was falsy when constructed, this property was set to the type name. Otherwise, it's undefined. |
+| .**type** | string | The type name. This is also the instance's primitive value. |
+| .**objectType** | string | The object name used by `Object.prototype.toString()`.. |
+| .**primitive** | string | If the `objectType` argument was falsy when constructed, this property was set to the type name. Otherwise, it's undefined. |
+| .**object** | string | If the `objectType` argument was truthy when constructed, this property was set to the type name. Otherwise, it's undefined. |
 
 ### Example
 
 ```
-let u;
-let p = 2;
-let o = new Number(3);
-
-is(u).type;	// "undefined"
-is(p).type;	// "number"
+is(2).type;	// "number"
+is(2)+""	// "number"
+is(2) == "number";	//true
+is(2).primitive === "number";	// true
+is(2).object === "number";	// false
+is(2).objectType;	// undefined
+
+let o = new Number(2);
 is(o).type;	// "number"
 is(o)+""	// "number"
-
 is(o) == "number";	//true
 is(o).primitive === "number";	// false
 is(o).object === "number";	// true
+is(o).objectType;	// "Number"
 ```
 
 ---
@@ -62,8 +65,8 @@ is(o).object === "number";	// true
 
 For each of the type-testing methods, the only parameter is the item to be tested. The return value is a boolean.
 
-**is.primitive()**  
 **is.object()**  
+**is.primitive()**  
 
 **is.undefined()**  
 **is.null()**  
@@ -77,9 +80,14 @@ For each of the type-testing methods, the only parameter is the item to be teste
 **is.boolean()**  
 **is.string()**  
 **is.symbol()**  
+**is.function()**  
+
 **is.array()**  
 **is.date()**  
+**is.error()**  
 **is.regexp()**  
-**is.function()**  
-
-
+**is.map()**  
+**is.set()**  
+**is.weakmap()**  
+**is.weakset()**  
+**is.promise()**  

isType.mjs

@@ -1,63 +1,98 @@
 
-const basicTypes = [
-	"undefined",
-	"null",
-	"number",
-	"bigint",
-	"boolean",
-	"string",
-	"symbol",
-	"array",
-	"date",
-	"regexp",
-	"function",
-];
-
 class Type extends String {
 	/**
 	 * @constructor
 	 * @param {string} typeName - The type's name, regardless of whether it's an object or a primitive.
-	 * @param {boolean} [isPrimitive] - Is this a primitive value?
+	 * @param {string} [objectType] - If this is an object, the object's name. Falsy for a primitive.
 	 */
-	constructor(typeName, isPrimitive){
-		typeName = String(typename);
+	constructor(typeName, objectType){
+		if(!(typeof typeName === "string" || typeName instanceof String))
+			throw new TypeError("'typeName' must be a 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);
-		this.type = this[ isPrimitive ? "primitive" : "object" ] = typeName;
+		
+		if(objectType){
+			this.type = this.object = typeName;
+			this.objectType = objectType;
+		}
+		else{
+			this.type = this.primitive = typeName;
+		}
 	}
 }
 
+function getToStringTag(obj){
+	return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
 function is(value){
 	if(value === void 0)
-		return new Type("undefined", true);
+		return new Type("undefined");
 	if(value === null)
-		return new Type("null", true);
+		return new Type("null");
 	const type = typeof value;
 	if(type === "function")
-		return new Type("function", false);
+		return new Type("function", "Function");
 	if(type === "object"){
-		const deepType = Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
-		if(deepType.match(new RegExp(`^${basicTypes.join("|")}$`, "ui")))
-			return new Type(deepType, false);
-		return new Type(type, false);
+		const toStringTag = getToStringTag(value);
+		for(const objectType of ["Boolean","Number","String"]){
+			if(value instanceof globalThis[objectType])
+				return new Type(objectType.toLowerCase(), toStringTag);
+		}
+		return new Type(type, toStringTag);
 	}
-	return new Type(type, true);
+	return new Type(type);
 }
 
-function fn(type){
-	return (v)=>(is(v).type === type);
-}
 
-is.primitive = (v)=>(is(v).primitive !== void 0);
-is.object = (v)=>(is(v).object !== void 0);
+is.object = (v)=>(v instanceof Object);
+is.primitive = (v)=>!is.object(v);
 
-for(const type of basicTypes){
-	is[type] = fn(type);
+const typeofTypes = [
+	/*** primitives ***/
+	"undefined",
+	"null",
+	"bigint",
+	"symbol",
+	
+	/*** primitives & objects ***/
+	"boolean",
+	"number",
+	"string",
+	
+	/*** objects ***/
+	//"object",
+	"function",
+];
+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 otherCommonTypes = [
+	"Error",
+	"Date",
+	"RegExp",
+	"Array",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Promise",
+];
+for(const objectType of otherCommonTypes){
+	is[objectType.toLowerCase()] = (v)=>(v instanceof globalThis[objectType]);
+}
+
 
 
 export { is as default };