- rewritten

- add README

Author: wizard04wsu

README.md

@@ -1,2 +1,85 @@
-# 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)
+- ***isPrimitive*** - (boolean) Optional.
+
+| 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. |
+
+### Example
+
+```
+let u;
+let p = 2;
+let o = new Number(3);
+
+is(u).type;	// "undefined"
+is(p).type;	// "number"
+is(o).type;	// "number"
+is(o)+""	// "number"
+
+is(o) == "number";	//true
+is(o).primitive === "number";	// false
+is(o).object === "number";	// true
+```
+
+---
+
+
+## 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.primitive()**  
+**is.object()**  
+
+**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.array()**  
+**is.date()**  
+**is.regexp()**  
+**is.function()**  
+
+

isType.mjs

@@ -1,81 +1,62 @@
-/**
- * A more robust 'typeof'.
- * https://github.com/wizard04wsu/javascript-type-testing
- * 
- * 
- * For each of the type testing methods, the only parameter is the item to be tested. These methods do not perform coercion.
- * 
- * is(o) - Returns the item's type.
- *       - NaN is considered its own type (instead of a number), since it essentially represents something that cannot be converted to a number.
- *       - For objects, the type of the object is given instead of just 'object' (e.g., 'Array').
- * 
- * is.defined(o)
- * is.undefined(o)
- * is.null(o)
- * is.nan(o) - NaN or a Number object with value NaN
- * 
- * is.array(o)
- * is.bigint(o)
- * is.boolean(o)
- * is.date(o)
- * is.function(o)
- * is.number(o) - excludes NaN
- * is.number.infinite(o)
- * is.number.nan(o) - same as is.nan(o)
- * is.number.real(o)
- * is.regexp(o)
- * is.string(o)
- * is.symbol(o)
- * 
- * is.object(o)
- * is.primitive(o)
- * 
- * 
- * is.noConflict() - Restores 'is' to what it was before this script replaced it.
- */
 
-function is(o){
-	if(o === void 0) return "undefined";
-	const t = typeof o;
-	if(t === "object"){
-		if(o === null) return "null";
-		let name = Object.prototype.toString.call(o).slice(8, -1);
-		if(name === "Number" && 1*o !== 1*o) return "NaN";
-		return name;	//object type
+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?
+	 */
+	constructor(typeName, isPrimitive){
+		typeName = String(typename);
+		super(typeName);
+		this.type = this[ isPrimitive ? "primitive" : "object" ] = typeName;
 	}
-	if(o !== o) return "NaN";
-	return t;	//primitive type or "function"
 }
 
-function fn(type, eitherCase){
-	if(eitherCase) return function (o){ return is(o).toLowerCase() === type; };
-	return function (o){ return is(o) === type; };
+function is(value){
+	if(value === void 0)
+		return new Type("undefined", true);
+	if(value === null)
+		return new Type("null", true);
+	const type = typeof value;
+	if(type === "function")
+		return new Type("function", false);
+	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);
+	}
+	return new Type(type, true);
 }
 
-is.undefined = function (o){ return o === void 0; };
-is.defined = function (o){ return o !== void 0; };
-is.null = function (o){ return o === null; };
-
-is.nan = fn("NaN");	//NaN or a Number object with value NaN
-//Note that JavaScript doesn't correctly treat all undefined forms as NaN (e.g., 1/0 and 0**0).
+function fn(type){
+	return (v)=>(is(v).type === type);
+}
 
-is.array = fn("Array");
-is.bigint = fn("bigint");
-is.boolean = fn("boolean", true);
-is.date = fn("Date");
-is.function = fn("function");
-is.number = fn("number", true);	//excludes NaN
-is.number.nan = is.nan;
-is.regexp = fn("RegExp");
-is.string = fn("string", true);
-is.symbol = fn("symbol");
+is.primitive = (v)=>(is(v).primitive !== void 0);
+is.object = (v)=>(is(v).object !== void 0);
 
-const infinity = 1/0;	//Technically, 1/0 is an undefined form, but JavaScript treats it as Infinity.
-is.number.infinite = function (o){ return is.number(o) && Math.abs(o) === infinity; };
-is.number.real = function (o){ return is.number(o) && Math.abs(o) !== infinity; };
+for(const type of basicTypes){
+	is[type] = fn(type);
+}
 
-is.object = function (o){ let t = typeof o; return (t === "object" && o !== null) || t === "function"; };
-is.primitive = function (o){ return !is.object(o); };
+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).