Merge pull request #2 from wizard04wsu/dev

Dev

Author: wizard04wsu

README.md

@@ -1,2 +1,93 @@
-# javascript-type-testing
-Improved JavaScript type testing
+# Improved JavaScript Type Testing
+A robust alternative to JavaScript's `typeof` keyword.
+
+This is a JavaScript module that exports: [`is`](#is) (default)
+
+---
+
+
+## Get the type
+
+### is()
+
+The **is()** function determines the type of its argument and returns a [Type](#the-type-class) object.
+
+Syntax:
+> `is(value)`
+
+Parameters:
+- ***value*** - The value to determine the type of.
+
+Return value:
+- A [Type](#the-type-class) object.
+
+### The Type class
+
+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.
+
+Syntax:
+> `new Type(typeName, isPrimitive)`
+
+Parameters:
+- ***typeName*** - (string)
+- ***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 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
+
+```
+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"
+```
+
+---
+
+
+## Test for a type
+
+For each of the type-testing methods, the only parameter is the item to be tested. The return value is a boolean.
+
+**is.object()**  
+**is.primitive()**  
+
+**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.bigint()**  
+**is.boolean()**  
+**is.string()**  
+**is.symbol()**  
+**is.function()**  
+
+**is.array()**  
+**is.date()**  
+**is.error()**  
+**is.regexp()**  
+**is.map()**  
+**is.set()**  
+**is.weakmap()**  
+**is.weakset()**  
+**is.promise()**  

isType.js

@@ -0,0 +1,98 @@
+
+class Type extends String {
+	/**
+	 * @constructor
+	 * @param {string} typeName - The type's name, regardless of whether it's an object or a primitive.
+	 * @param {string} [objectType] - If this is an object, the object's name. Falsy for a primitive.
+	 */
+	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);
+		
+		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");
+	if(value === null)
+		return new Type("null");
+	const type = typeof value;
+	if(type === "function")
+		return new Type("function", "Function");
+	if(type === "object"){
+		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);
+}
+
+
+is.object = (v)=>(v instanceof Object);
+is.primitive = (v)=>!is.object(v);
+
+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 };

isType.mjs

@@ -0,0 +1,5 @@
+<html><head><title>isType test</title><script src="test.js" type="module"></script></head><body>
+	
+	View the console.
+	
+</body></html>