rewrite; test and docs WIP

Author: wizard04wsu

isType.mjs.js

@@ -1,164 +1,99 @@
 /** @module isType */
 
-// Type names and the class each refers to.
-const OBJECT_TYPES = {
-	array:     Array,
-	boolean:   Boolean,
-	date:      Date,
-	error:     Error,
-	function:  Function,
-	map:       Map,
-	number:    Number,
-	promise:   Promise,
-	regex:     RegExp,
-	set:       Set,
-	string:    String,
-	weakmap:   WeakMap,
-	weakset:   WeakSet,
+const TYPES = {
+	array:     {                         class: Array    },
+	bigint:    { primitive: "bigint"                     },
+	boolean:   { primitive: "boolean",   class: Boolean  },
+	date:      {                         class: Date     },
+	error:     {                         class: Error    },
+	function:  {                         class: Function },
+	map:       {                         class: Map      },
+	nan:       {},
+	null:      {},
+	number:    {},
+	numberish: { primitive: "number",    class: Number   },
+	object:    {},
+	promise:   {                         class: Promise  },
+	regex:     {                         class: RegExp   },
+	set:       {                         class: Set      },
+	string:    { primitive: "string",    class: String   },
+	symbol:    { primitive: "symbol",                    },
+	undefined: { primitive: "undefined",                 },
+	weakmap:   {                         class: WeakMap  },
+	weakset:   {                         class: WeakSet  },
 };
 
-// Initial type names.
-const TYPE_NAMES = [
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"error",
-	"function",
-	"map",
-	"nan",
-	"null",
-	"number",
-	"object",
-	"promise",
-	"regex",
-	"set",
-	"string",
-	"symbol",
-	"undefined",
-	"weakmap",
-	"weakset",
-];
-
-
 /**
- * Descriptors of a value's type.
- * @class Type
+ * A collection of boolean properties indicating the type of the given value.
+ * @class TypeTest
  * @extends {String}
  */
-class Type extends String {
-	
-	#name;
-	#typeofType;
-	#toStringTag;
-	#constructorName;
-	#isPrimitive;
+class TypeTest extends String {
 
 	/**
 	 * @constructor
-	 * @param {string} name - Custom type name.
-	 * @param {string} typeofType - The value returned by the `typeof` operator.
-	 * @param {string} [toStringTag] - For objects. The name used by `Object.prototype.toString.call()`.
-	 * @param {string} [constructorName] - For objects. The name of the argument's constructor.
+	 * @param {*} value - The value to be tested.
 	 */
-	constructor(name, typeofType, toStringTag, constructorName){
+	constructor(value){
 
-		super(name);
-		this.#name = name;
+		let typeName;
 
-		this.#typeofType = typeofType;
-		this.#toStringTag = toStringTag;
-		this.#constructorName = constructorName;
+		if(value === null){
+			typeName = "null";
+		}
+		else{
+			typeName = "object";
+			
+			for(const name in TYPES){
+				const type = TYPES[name];
+				if(typeof value === type.primitive || (type.class && value instanceof type.class)){
+					typeName = name;
+					break;
+				}
+			}
+		}
 
-		this.#isPrimitive = constructorName === void 0;
-	}
-	
-	/** @member {string} */
-	get type(){ return this.#name; }
-	
-	/** @member {string} */
-	get ["typeof"](){ return this.#typeofType; }
-	
-	/** @member {string} */
-	get toStringTag(){ return this.#toStringTag; }
-	
-	/** @member {string} */
-	get constructorName(){ return this.#constructorName; }
-	
-	/** @member {boolean} */
-	get isPrimitive(){ return this.#isPrimitive; }
-	
-	/** @member {boolean} */
-	get isObject(){ return !this.#isPrimitive; }
-}
-
-
-
-/**
- * Determine the type of a value.
- * @param {*} value
- * @returns {Type}
- */
-function is(value){
-	
-	let typeName,
-		typeofType = typeof value,
-		toStringTag,
-		constructorName;
-	
-	if(value instanceof Object){
-		toStringTag = Object.prototype.toString.call(value).slice(8, -1);
-		constructorName = value.constructor.name || "";
-	}
-	
-	if(value === null)
-		typeName = "null";
-	else if(Number.isNaN(value) || (value instanceof Number && Number.isNaN(value.valueOf())))
-		typeName = "nan";
-	else if(!["object", "function"].includes(typeofType))
-		typeName = typeofType;
-	else{
-		typeName = "object";
-		for(const name in OBJECT_TYPES){
-			if(value instanceof OBJECT_TYPES[name]){
-				typeName = name;
-				break;
+		if(typeName === "numberish"){
+			if(Number.isNaN(value) || (value instanceof Number && Number.isNaN(value.valueOf()))){
+				typeName = "nan";
+			}
+			else{
+				typeName = "number";
 			}
 		}
+		
+		super(typeName);
+		
+		for(const name in TYPES){
+			this[name] = typeName === name;
+		}
+		
+		this.numberish = this.number || this.nan;
+		if(this.number){
+			this.real = Number.isFinite(this.object ? value.valueOf() : value);
+			this.infinite = !this.real;
+		}
+		
+		this.primitive = !this.object;
+		this.objectish = this.object || this.null;
+		
+		this.defined = !this.undefined;
+		this.nullish = this.undefined || this.null;
+		
+		this.falsy = !value;
+		this.truthy = !this.falsy;
+		
+		if(this.string || this.array){
+			this.empty = value.length === 0;
+		}
+		else if(this.map || this.set || this.weakmap || this.weakset){
+			this.empty = value.size === 0;
+		}
 	}
-	
-	return new Type(typeName, typeofType, toStringTag, constructorName);
 }
 
-
-
-// Create type testers.
-
-for(const name of TYPE_NAMES){
-	is[name] = (v)=> is(v).type === name;
+function is(value){
+	return new TypeTest(value);
 }
 
-is.object = (v)=> is(v).isObject;
-is.primitive = (v)=> is(v).isPrimitive;
-
-is.defined = (v)=> !is.undefined(v);
-is.nullish = (v)=> (is.undefined(v) || is.null(v));
-
-is.falsy = (v)=> !v;
-is.truthy = (v)=> !!v;
-
-is.numberish = (v)=> (is.number(v) || is.nan(v));
-is.real = (v)=> (is.number(v) && Number.isFinite(v instanceof Number ? v.valueOf() : v));
-is.infinite = (v)=> (is.number(v) && !Number.isFinite(v instanceof Number ? v.valueOf() : v));
-
-
-
-// Create additional methods.
-
-is.empty = (v)=> (v?.length === 0 || v?.size === 0);
-
-is.of = (v, c)=> v instanceof c;
-
-
-
 export { is as default };