phane-js-utils 1.0.8 → 1.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 phane-tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,27 +1,27 @@
 <a name="module_DataTypeCheck"></a>
 
 ## DataTypeCheck
-Data Check helpers.
+Data Type Check helpers.
 
 
 * [DataTypeCheck](#module_DataTypeCheck)
-    * [.checkIsNumber(userInput)](#module_DataTypeCheck.checkIsNumber) ⇒ <code>boolean</code> \| <code>undefined</code>
-    * [.checkIsString(userInput)](#module_DataTypeCheck.checkIsString) ⇒ <code>boolean</code> \| <code>undefined</code>
-    * [.checkIsBoolean(userInput)](#module_DataTypeCheck.checkIsBoolean) ⇒ <code>boolean</code> \| <code>undefined</code>
-    * [.checkIsBigint(userInput)](#module_DataTypeCheck.checkIsBigint) ⇒ <code>boolean</code> \| <code>undefined</code>
-    * [.checkIsFunction(userInput)](#module_DataTypeCheck.checkIsFunction) ⇒ <code>boolean</code> \| <code>undefined</code>
-    * [.checkIsObject(userInput)](#module_DataTypeCheck.checkIsObject) ⇒ <code>boolean</code> \| <code>undefined</code>
+    * [.checkIsNumber(userInput)](#module_DataTypeCheck.checkIsNumber) ⇒ <code>boolean</code>
+    * [.checkIsString(userInput)](#module_DataTypeCheck.checkIsString) ⇒ <code>boolean</code>
+    * [.checkIsBoolean(userInput)](#module_DataTypeCheck.checkIsBoolean) ⇒ <code>boolean</code>
+    * [.checkIsBigint(userInput)](#module_DataTypeCheck.checkIsBigint) ⇒ <code>boolean</code>
+    * [.checkIsFunction(userInput)](#module_DataTypeCheck.checkIsFunction) ⇒ <code>boolean</code>
+    * [.checkIsObject(userInput)](#module_DataTypeCheck.checkIsObject) ⇒ <code>boolean</code>
     * [.checkObjectLength(userInput)](#module_DataTypeCheck.checkObjectLength) ⇒ <code>number</code> \| <code>undefined</code>
-    * [.checkIsArray(userInput)](#module_DataTypeCheck.checkIsArray) ⇒ <code>boolean</code> \| <code>undefined</code>
+    * [.checkIsArray(userInput)](#module_DataTypeCheck.checkIsArray) ⇒ <code>boolean</code>
     * [.checkArrayLength(userInput)](#module_DataTypeCheck.checkArrayLength) ⇒ <code>number</code> \| <code>undefined</code>
 
 <a name="module_DataTypeCheck.checkIsNumber"></a>
 
-### DataTypeCheck.checkIsNumber(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsNumber(userInput) ⇒ <code>boolean</code>
 Check if the user input is a number or not.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if number, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if number, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -29,15 +29,15 @@ Check if the user input is a number or not.
 
 **Example**  
 ```js
-checkIsNumber(37) => true
+checkIsNumber(37) => true
 ```
 <a name="module_DataTypeCheck.checkIsString"></a>
 
-### DataTypeCheck.checkIsString(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsString(userInput) ⇒ <code>boolean</code>
 Check if the user input is a string or not.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if string, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if string, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -45,15 +45,15 @@ Check if the user input is a string or not.
 
 **Example**  
 ```js
-checkIsString(37) => false
+checkIsString(37) // false
 ```
 <a name="module_DataTypeCheck.checkIsBoolean"></a>
 
-### DataTypeCheck.checkIsBoolean(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsBoolean(userInput) ⇒ <code>boolean</code>
 Check if the user input is a boolean or not.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if boolean, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if boolean, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -61,15 +61,15 @@ Check if the user input is a boolean or not.
 
 **Example**  
 ```js
-checkIsBoolean(37) => false
+checkIsBoolean(37) => false
 ```
 <a name="module_DataTypeCheck.checkIsBigint"></a>
 
-### DataTypeCheck.checkIsBigint(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsBigint(userInput) ⇒ <code>boolean</code>
 Check if the user input is a Bigint or not.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if bigint, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if bigint, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -77,15 +77,15 @@ Check if the user input is a Bigint or not.
 
 **Example**  
 ```js
-checkIsBigint(37n) => true
+checkIsBigint(37n) => true
 ```
 <a name="module_DataTypeCheck.checkIsFunction"></a>
 
-### DataTypeCheck.checkIsFunction(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsFunction(userInput) ⇒ <code>boolean</code>
 Check if the user input is a function.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if function, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if function, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -93,15 +93,15 @@ Check if the user input is a function.
 
 **Example**  
 ```js
-checkIsFunction(function() {}) => true
+checkIsFunction(function() {}) => true
 ```
 <a name="module_DataTypeCheck.checkIsObject"></a>
 
-### DataTypeCheck.checkIsObject(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsObject(userInput) ⇒ <code>boolean</code>
 Check if the user input is an object.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if object, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if object, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -109,7 +109,7 @@ Check if the user input is an object.
 
 **Example**  
 ```js
-checkIsObject({}) => true
+checkIsObject({}) // true
 ```
 <a name="module_DataTypeCheck.checkObjectLength"></a>
 
@@ -125,15 +125,15 @@ Get the number of key-value pairs in an object.
 
 **Example**  
 ```js
-checkObjectLength({ a: 1, b: 2 }) => 2
+checkObjectLength({ a: 1, b: 2 }) => 2
 ```
 <a name="module_DataTypeCheck.checkIsArray"></a>
 
-### DataTypeCheck.checkIsArray(userInput) ⇒ <code>boolean</code> \| <code>undefined</code>
+### DataTypeCheck.checkIsArray(userInput) ⇒ <code>boolean</code>
 Check if the user input is an array.
 
 **Kind**: static method of [<code>DataTypeCheck</code>](#module_DataTypeCheck)  
-**Returns**: <code>boolean</code> \| <code>undefined</code> - Returns true if array, false if not, undefined if input is null/undefined  
+**Returns**: <code>boolean</code> - Returns true if array, false if not  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -141,7 +141,7 @@ Check if the user input is an array.
 
 **Example**  
 ```js
-checkIsArray([1, 2, 3]) => true
+checkIsArray([1, 2, 3]) => true
 ```
 <a name="module_DataTypeCheck.checkArrayLength"></a>
 
@@ -157,5 +157,5 @@ Get the length of an array.
 
 **Example**  
 ```js
-checkArrayLength([1, 2, 3])  => 3
+checkArrayLength([1, 2, 3])  => 3
 ```

package/index.js

@@ -1 +1 @@
-export * from "./js/index.js";
+export * from "./js/dataTypeCheck.js";

package/js/dataTypeCheck.js

@@ -1,5 +1,5 @@
 /**
- * Data Check helpers.
+ * Data Type Check helpers.
  * @module DataTypeCheck
  */
 
@@ -10,20 +10,21 @@
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if number, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if number, false if not
  *
  * @example
  * checkIsNumber(37) => true
  *
  * checkIsNumber("hello") => false
  *
- * checkIsNumber() => undefined
+ * checkIsNumber() => false
  *
- * checkIsNumber(null) => undefined
+ * checkIsNumber(null) => false
  *
+ * checkIsNumber(undefined) => false
  */
+
 export function checkIsNumber(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return typeof userInput === "number";
 }
 
@@ -34,20 +35,20 @@ export function checkIsNumber(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if string, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if string, false if not
  *
- * @example
- * checkIsString(37) => false
+  * @example
+ * checkIsString(37) // false
  *
- * checkIsString("hello") => true
+ * checkIsString("hello") // true
  *
- * checkIsString() => undefined
+ * checkIsString() // false
  *
- * checkIsString(null) => undefined
+ * checkIsString(null) // false
  *
+ * checkIsString(undefined) // false
  */
 export function checkIsString(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return typeof userInput === "string";
 }
 
@@ -58,7 +59,7 @@ export function checkIsString(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if boolean, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if boolean, false if not
  *
  * @example
  * checkIsBoolean(37) => false
@@ -67,13 +68,12 @@ export function checkIsString(userInput) {
  * 
  * checkIsBoolean(false) => true
  *
- * checkIsBoolean() => undefined
+ * checkIsBoolean() => false
  *
- * checkIsBoolean(null) => undefined
+ * checkIsBoolean(null) => false
  *
  */
 export function checkIsBoolean(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return typeof userInput === "boolean";
 }
 
@@ -84,7 +84,7 @@ export function checkIsBoolean(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if bigint, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if bigint, false if not
  *
  * @example
  * checkIsBigint(37n) => true
@@ -93,12 +93,11 @@ export function checkIsBoolean(userInput) {
  * 
  * checkIsBigint(37) => false
  * 
- * checkIsBigint() => undefined
+ * checkIsBigint() => false
  *
- * checkIsBigint(null) => undefined
+ * checkIsBigint(null) => false
  */
 export function checkIsBigint(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return typeof userInput === "bigint";
 }
 
@@ -109,7 +108,7 @@ export function checkIsBigint(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if function, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if function, false if not
  *
  * @example
  * checkIsFunction(function() {}) => true
@@ -118,12 +117,11 @@ export function checkIsBigint(userInput) {
  *
  * checkIsFunction(42) => false
  *
- * checkIsFunction(null) => undefined
+ * checkIsFunction(null) => false
  *
- * checkIsFunction()  => undefined
+ * checkIsFunction()  => false
  */
 export function checkIsFunction(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return typeof userInput === "function";
 }
 
@@ -134,22 +132,21 @@ export function checkIsFunction(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if object, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if object, false if not
  *
  * @example
- * checkIsObject({}) => true
+ * checkIsObject({}) // true
  *
- * checkIsObject({ a: 1 }) => true
+ * checkIsObject({ a: 1 }) // true
  *
- * checkIsObject([]) => true (arrays are objects in JavaScript)
+ * checkIsObject([]) // false
  *
- * checkIsObject(null) => undefined
+ * checkIsObject(null) // false
  *
- * checkIsObject(42) => false
+ * checkIsObject(42) // false
  */
 export function checkIsObject(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
-  return typeof userInput === "object";
+  return (typeof userInput === "object" &&  userInput !== null && !Array.isArray(userInput));
 }
 
 /**
@@ -166,7 +163,7 @@ export function checkIsObject(userInput) {
  *
  * checkObjectLength({}) => 0
  *
- * checkObjectLength([]) => 0 (arrays are objects in JavaScript)
+ * checkObjectLength([]) => undefined
  *
  * checkObjectLength(null) => undefined
  *
@@ -184,7 +181,7 @@ export function checkObjectLength(userInput) {
  * @memberof module:DataTypeCheck
  *
  * @param {*} userInput - Any value to check
- * @returns {boolean|undefined} Returns true if array, false if not, undefined if input is null/undefined
+ * @returns {boolean} Returns true if array, false if not
  *
  * @example
  * checkIsArray([1, 2, 3]) => true
@@ -193,12 +190,15 @@ export function checkObjectLength(userInput) {
  *
  * checkIsArray({})  => false
  *
- * checkIsArray(null) => undefined
+ * checkIsArray(null) => false
+ * 
+ * checkIsArray() => false
+ * 
+ * checkIsArray(undefined) => false
  *
  * checkIsArray(42) => false
  */
 export function checkIsArray(userInput) {
-  if (userInput === null || userInput === undefined) return undefined;
   return Array.isArray(userInput);
 }
 
@@ -217,6 +217,8 @@ export function checkIsArray(userInput) {
  * checkArrayLength([]) => 0
  *
  * checkArrayLength({}) => undefined
+ * 
+ * checkArrayLength() => undefined
  *
  * checkArrayLength(null) => undefined
  *

package/js/dataTypeCheck.test.js

@@ -7,157 +7,243 @@ import {
   checkIsObject,
   checkObjectLength,
   checkIsArray,
-  checkArrayLength
-} from './dataTypeCheck.js'; 
+  checkArrayLength,
+} from "./dataTypeCheck.js";
 
+describe("Check Is Number Function", () => {
+  test("42 should return true", () => expect(checkIsNumber(42)).toBe(true));
+  test("0 should return true", () => expect(checkIsNumber(0)).toBe(true));
+  test("-1 should return true", () => expect(checkIsNumber(-1)).toBe(true));
+  test("NaN should return true", () => expect(checkIsNumber(NaN)).toBe(true));
+  test("Infinity should return true", () =>
+    expect(checkIsNumber(Infinity)).toBe(true));
+  test('"hello" should return false', () =>
+    expect(checkIsNumber("hello")).toBe(false));
+  test("true should return false", () =>
+    expect(checkIsNumber(true)).toBe(false));
+  test("false should return false", () =>
+    expect(checkIsNumber(false)).toBe(false));
+  test("[] should return false", () => expect(checkIsNumber([])).toBe(false));
+  test("{} should return false", () => expect(checkIsNumber({})).toBe(false));
+  test("() => {} should return false", () =>
+    expect(checkIsNumber(() => {})).toBe(false));
+  test("123n should return false", () =>
+    expect(checkIsNumber(123n)).toBe(false));
+  test("null should return false", () =>
+    expect(checkIsNumber(null)).toBe(false));
+  test("undefined should return false", () =>
+    expect(checkIsNumber(undefined)).toBe(false));
+  test("new Number(42) should return false", () =>
+    expect(checkIsNumber(new Number(42))).toBe(false));
+  test("3.14 should return true", () => expect(checkIsNumber(3.14)).toBe(true));
+  test("-Infinity should return true", () =>
+    expect(checkIsNumber(-Infinity)).toBe(true));
+  test("1e5 should return true", () => expect(checkIsNumber(1e5)).toBe(true));
+  test('"42" should return false', () =>
+    expect(checkIsNumber("42")).toBe(false));
+  test('Symbol("42") should return false', () =>
+    expect(checkIsNumber(Symbol("42"))).toBe(false));
+  test("0n should return false", () => expect(checkIsNumber(0n)).toBe(false));
+});
 
-describe("DataTypeCheck Helpers - Comprehensive Tests", () => {
+describe("Check Is String Function", () => {
+  test('"hello" should return true', () =>
+    expect(checkIsString("hello")).toBe(true));
+  test('"" should return true', () => expect(checkIsString("")).toBe(true));
+  test('"123" should return true', () =>
+    expect(checkIsString("123")).toBe(true));
+  test("42 should return false", () => expect(checkIsString(42)).toBe(false));
+  test("true should return false", () =>
+    expect(checkIsString(true)).toBe(false));
+  test("false should return false", () =>
+    expect(checkIsString(false)).toBe(false));
+  test("[] should return false", () => expect(checkIsString([])).toBe(false));
+  test("{} should return false", () => expect(checkIsString({})).toBe(false));
+  test("() => {} should return false", () =>
+    expect(checkIsString(() => {})).toBe(false));
+  test("123n should return false", () =>
+    expect(checkIsString(123n)).toBe(false));
+  test("null should return false", () =>
+    expect(checkIsString(null)).toBe(false));
+  test("undefined should return false", () =>
+    expect(checkIsString(undefined)).toBe(false));
+  test('new String("hello") should return false', () =>
+    expect(checkIsString(new String("hello"))).toBe(false));
+  test('"   " should return true', () =>
+    expect(checkIsString("   ")).toBe(true));
+  test("template literal should return true", () =>
+    expect(checkIsString(`hello ${42}`)).toBe(true));
+  test('Symbol("test") should return false', () =>
+    expect(checkIsString(Symbol("test"))).toBe(false));
+});
 
-  describe("checkIsNumber", () => {
-    // Positive
-    test('42 should return true', () => expect(checkIsNumber(42)).toBe(true));
-    test('0 should return true', () => expect(checkIsNumber(0)).toBe(true));
-    test('-1 should return true', () => expect(checkIsNumber(-1)).toBe(true));
-    test('NaN should return true', () => expect(checkIsNumber(NaN)).toBe(true));
-    test('Infinity should return true', () => expect(checkIsNumber(Infinity)).toBe(true));
-    // Negative
-    test('"hello" should return false', () => expect(checkIsNumber("hello")).toBe(false));
-    test('true should return false', () => expect(checkIsNumber(true)).toBe(false));
-    test('false should return false', () => expect(checkIsNumber(false)).toBe(false));
-    test('[] should return false', () => expect(checkIsNumber([])).toBe(false));
-    test('{} should return false', () => expect(checkIsNumber({})).toBe(false));
-    test('() => {} should return false', () => expect(checkIsNumber(() => {})).toBe(false));
-    test('123n should return false', () => expect(checkIsNumber(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsNumber(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsNumber(undefined)).toBeUndefined());
-  });
+describe("Check Is Boolean Function", () => {
+  test("true should return true", () =>
+    expect(checkIsBoolean(true)).toBe(true));
+  test("false should return true", () =>
+    expect(checkIsBoolean(false)).toBe(true));
+  test("0 should return false", () => expect(checkIsBoolean(0)).toBe(false));
+  test("1 should return false", () => expect(checkIsBoolean(1)).toBe(false));
+  test('"true" should return false', () =>
+    expect(checkIsBoolean("true")).toBe(false));
+  test("[] should return false", () => expect(checkIsBoolean([])).toBe(false));
+  test("{} should return false", () => expect(checkIsBoolean({})).toBe(false));
+  test("() => {} should return false", () =>
+    expect(checkIsBoolean(() => {})).toBe(false));
+  test("123n should return false", () =>
+    expect(checkIsBoolean(123n)).toBe(false));
+  test("null should return false", () =>
+    expect(checkIsBoolean(null)).toBe(false));
+  test("undefined should return false", () =>
+    expect(checkIsBoolean(undefined)).toBe(false));
+  test("new Boolean(true) should return false", () =>
+    expect(checkIsBoolean(new Boolean(true))).toBe(false));
+  test("true && false should return true", () =>
+    expect(checkIsBoolean(true && false)).toBe(true));
+  test("1 === 1 should return true", () =>
+    expect(checkIsBoolean(1 === 1)).toBe(true));
+  test("Symbol() should return false", () =>
+    expect(checkIsBoolean(Symbol())).toBe(false));
+});
 
-  describe("checkIsString", () => {
-    // Positive
-    test('"hello" should return true', () => expect(checkIsString("hello")).toBe(true));
-    test('"" should return true', () => expect(checkIsString("")).toBe(true));
-    test('"123" should return true', () => expect(checkIsString("123")).toBe(true));
-    // Negative
-    test('42 should return false', () => expect(checkIsString(42)).toBe(false));
-    test('true should return false', () => expect(checkIsString(true)).toBe(false));
-    test('false should return false', () => expect(checkIsString(false)).toBe(false));
-    test('[] should return false', () => expect(checkIsString([])).toBe(false));
-    test('{} should return false', () => expect(checkIsString({})).toBe(false));
-    test('() => {} should return false', () => expect(checkIsString(() => {})).toBe(false));
-    test('123n should return false', () => expect(checkIsString(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsString(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsString(undefined)).toBeUndefined());
-  });
+describe("Check Is Bigint Function", () => {
+  test("0n should return true", () => expect(checkIsBigint(0n)).toBe(true));
+  test("123n should return true", () => expect(checkIsBigint(123n)).toBe(true));
+  test("-999n should return true", () =>
+    expect(checkIsBigint(-999n)).toBe(true));
+  test("42 should return false", () => expect(checkIsBigint(42)).toBe(false));
+  test('"123"', () => expect(checkIsBigint("123")).toBe(false));
+  test("true should return false", () =>
+    expect(checkIsBigint(true)).toBe(false));
+  test("[] should return false", () => expect(checkIsBigint([])).toBe(false));
+  test("{} should return false", () => expect(checkIsBigint({})).toBe(false));
+  test("() => {} should return false", () =>
+    expect(checkIsBigint(() => {})).toBe(false));
+  test("null should return false", () =>
+    expect(checkIsBigint(null)).toBe(false));
+  test("undefined should return false", () =>
+    expect(checkIsBigint(undefined)).toBe(false));
+  test("Object(1n) should return false", () =>
+    expect(checkIsBigint(Object(1n))).toBe(false));
+  test("very large bigint should return true", () =>
+    expect(checkIsBigint(9007199254740993123456789n)).toBe(true));
+  test("BigInt(42) should return true", () =>
+    expect(checkIsBigint(BigInt(42))).toBe(true));
+  test("NaN should return false", () => expect(checkIsBigint(NaN)).toBe(false));
+  test("Symbol() should return false", () =>
+    expect(checkIsBigint(Symbol())).toBe(false));
+});
 
-  describe("checkIsBoolean", () => {
-    // Positive
-    test('true should return true', () => expect(checkIsBoolean(true)).toBe(true));
-    test('false should return true', () => expect(checkIsBoolean(false)).toBe(true));
-    // Negative
-    test('0 should return false', () => expect(checkIsBoolean(0)).toBe(false));
-    test('1 should return false', () => expect(checkIsBoolean(1)).toBe(false));
-    test('"true" should return false', () => expect(checkIsBoolean("true")).toBe(false));
-    test('[] should return false', () => expect(checkIsBoolean([])).toBe(false));
-    test('{} should return false', () => expect(checkIsBoolean({})).toBe(false));
-    test('() => {} should return false', () => expect(checkIsBoolean(() => {})).toBe(false));
-    test('123n should return false', () => expect(checkIsBoolean(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsBoolean(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsBoolean(undefined)).toBeUndefined());
-  });
+describe("Check Is Function Function", () => {
+  test('function declaration should return true', () => expect(checkIsFunction(function() {})).toBe(true));
+  test('arrow function should return true', () => expect(checkIsFunction(() => {})).toBe(true));
+  test('async function should return true', () => expect(checkIsFunction(async function() {})).toBe(true));
+  test('42 should return false', () => expect(checkIsFunction(42)).toBe(false));
+  test('"hello" should return false', () => expect(checkIsFunction("hello")).toBe(false));
+  test('true should return false', () => expect(checkIsFunction(true)).toBe(false));
+  test('[] should return false', () => expect(checkIsFunction([])).toBe(false));
+  test('{} should return false', () => expect(checkIsFunction({})).toBe(false));
+  test('123n should return false', () => expect(checkIsFunction(123n)).toBe(false));
+  test('null should return false', () => expect(checkIsFunction(null)).toBe(false));
+  test('undefined should return false', () => expect(checkIsFunction(undefined)).toBe(false));
+  test('class should return true', () => expect(checkIsFunction(class Test {})).toBe(true));
+  test('generator function should return true', () => expect(checkIsFunction(function* () {})).toBe(true));
+  test('async arrow function should return true', () => expect(checkIsFunction(async () => {})).toBe(true));
+  test('bound function should return true', () => expect(checkIsFunction(function () {}.bind(null))).toBe(true));
+  test('new Date() should return false', () => expect(checkIsFunction(new Date())).toBe(false));
+  test('Symbol() should return false', () => expect(checkIsFunction(Symbol())).toBe(false))
+});
 
-  describe("checkIsBigint", () => {
-    // Positive
-    test('0n should return true', () => expect(checkIsBigint(0n)).toBe(true));
-    test('123n should return true', () => expect(checkIsBigint(123n)).toBe(true));
-    test('-999n should return true', () => expect(checkIsBigint(-999n)).toBe(true));
-    // Negative
-    test('42 should return false', () => expect(checkIsBigint(42)).toBe(false));
-    test('"123"' , () => expect(checkIsBigint("123")).toBe(false));
-    test('true should return false', () => expect(checkIsBigint(true)).toBe(false));
-    test('[] should return false', () => expect(checkIsBigint([])).toBe(false));
-    test('{} should return false', () => expect(checkIsBigint({})).toBe(false));
-    test('() => {} should return false', () => expect(checkIsBigint(() => {})).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsBigint(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsBigint(undefined)).toBeUndefined());
-  });
+describe("Check Is Object Function", () => {
+  test('{} should return true', () => expect(checkIsObject({})).toBe(true));
+  test('{ a: 1 } should return true', () => expect(checkIsObject({ a: 1 })).toBe(true));
+  test('[] should return false', () => expect(checkIsObject([])).toBe(false));
+  test('42 should return false', () => expect(checkIsObject(42)).toBe(false));
+  test('"hello" should return false', () => expect(checkIsObject("hello")).toBe(false));
+  test('true should return false', () => expect(checkIsObject(true)).toBe(false));
+  test('() => {} should return false', () => expect(checkIsObject(() => {})).toBe(false));
+  test('123n should return false', () => expect(checkIsObject(123n)).toBe(false));
+  test('null should return false', () => expect(checkIsObject(null)).toBe(false));
+  test('undefined should return false', () => expect(checkIsObject(undefined)).toBe(false));
+  test('new Date() should return true', () => expect(checkIsObject(new Date())).toBe(true));
+  test('/abc/ should return true', () => expect(checkIsObject(/abc/)).toBe(true));
+  test('new Map() should return true', () => expect(checkIsObject(new Map())).toBe(true));
+  test('new Set() should return true', () => expect(checkIsObject(new Set())).toBe(true));
+  test('Object.create(null) should return true', () => expect(checkIsObject(Object.create(null))).toBe(true));
+  test('new Number(1) should return true', () => expect(checkIsObject(new Number(1))).toBe(true));
+  test('new String("x") should return true', () => expect(checkIsObject(new String("x"))).toBe(true));
+});
 
-  describe("checkIsFunction", () => {
-    // Positive
-    test('function declaration should return true', () => expect(checkIsFunction(function() {})).toBe(true));
-    test('arrow function should return true', () => expect(checkIsFunction(() => {})).toBe(true));
-    test('async function should return true', () => expect(checkIsFunction(async function() {})).toBe(true));
-    // Negative
-    test('42 should return false', () => expect(checkIsFunction(42)).toBe(false));
-    test('"hello" should return false', () => expect(checkIsFunction("hello")).toBe(false));
-    test('true should return false', () => expect(checkIsFunction(true)).toBe(false));
-    test('[] should return false', () => expect(checkIsFunction([])).toBe(false));
-    test('{} should return false', () => expect(checkIsFunction({})).toBe(false));
-    test('123n should return false', () => expect(checkIsFunction(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsFunction(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsFunction(undefined)).toBeUndefined());
+describe("Check Is Object Length Function", () => {
+  test('{} should return 0', () => expect(checkObjectLength({})).toBe(0));
+  test('{ a: 1, b: 2 } should return 2', () => expect(checkObjectLength({ a: 1, b: 2 })).toBe(2));
+  test('[] should return undefined', () => expect(checkObjectLength([])).toBe(undefined));
+  test('42 should return undefined', () => expect(checkObjectLength(42)).toBeUndefined());
+  test('"hello" should return undefined', () => expect(checkObjectLength("hello")).toBeUndefined());
+  test('null should return undefined', () => expect(checkObjectLength(null)).toBeUndefined());
+  test('undefined should return undefined', () => expect(checkObjectLength(undefined)).toBeUndefined());
+  test('() => {} should return undefined', () => expect(checkObjectLength(() => {})).toBeUndefined());
+  test('object with prototype properties should return only own keys count', () => {
+    const parent = { a: 1 };
+    const child = Object.create(parent);
+    child.b = 2;
+    expect(checkObjectLength(child)).toBe(1);
   });
-
-  describe("checkIsObject", () => {
-    // Positive
-    test('{} should return true', () => expect(checkIsObject({})).toBe(true));
-    test('{ a: 1 } should return true', () => expect(checkIsObject({ a: 1 })).toBe(true));
-    test('[] should return true (arrays are objects)', () => expect(checkIsObject([])).toBe(true));
-    // Negative
-    test('42 should return false', () => expect(checkIsObject(42)).toBe(false));
-    test('"hello" should return false', () => expect(checkIsObject("hello")).toBe(false));
-    test('true should return false', () => expect(checkIsObject(true)).toBe(false));
-    test('() => {} should return false', () => expect(checkIsObject(() => {})).toBe(false));
-    test('123n should return false', () => expect(checkIsObject(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsObject(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsObject(undefined)).toBeUndefined());
+  test('object with non-enumerable properties should return 0', () => {
+    const obj = {};
+    Object.defineProperty(obj, 'hidden', {
+      value: 1,
+      enumerable: false,
+    });
+    expect(checkObjectLength(obj)).toBe(0);
   });
-
-  describe("checkObjectLength", () => {
-    // Positive
-    test('{} should return 0', () => expect(checkObjectLength({})).toBe(0));
-    test('{ a: 1, b: 2 } should return 2', () => expect(checkObjectLength({ a: 1, b: 2 })).toBe(2));
-    test('[] should return 0 (array is object)', () => expect(checkObjectLength([])).toBe(0));
-    // Negative / Non-object
-    test('42 should return undefined', () => expect(checkObjectLength(42)).toBeUndefined());
-    test('"hello" should return undefined', () => expect(checkObjectLength("hello")).toBeUndefined());
-    test('null should return undefined', () => expect(checkObjectLength(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkObjectLength(undefined)).toBeUndefined());
-    test('() => {} should return undefined', () => expect(checkObjectLength(() => {})).toBeUndefined());
+  test('object with symbol keys should return 0', () => {
+    const sym = Symbol('key');
+    const obj = { [sym]: 1 };
+    expect(checkObjectLength(obj)).toBe(0);
   });
-
-  describe("checkIsArray", () => {
-    // Positive
-    test('[] should return true', () => expect(checkIsArray([])).toBe(true));
-    test('[1,2,3] should return true', () => expect(checkIsArray([1,2,3])).toBe(true));
-    // Negative
-    test('{} should return false', () => expect(checkIsArray({})).toBe(false));
-    test('42 should return false', () => expect(checkIsArray(42)).toBe(false));
-    test('"hello" should return false', () => expect(checkIsArray("hello")).toBe(false));
-    test('true should return false', () => expect(checkIsArray(true)).toBe(false));
-    test('123n should return false', () => expect(checkIsArray(123n)).toBe(false));
-    // Null / Undefined
-    test('null should return undefined', () => expect(checkIsArray(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkIsArray(undefined)).toBeUndefined());
+  test('frozen object should return correct length', () => {
+    const obj = Object.freeze({ a: 1, b: 2 });
+    expect(checkObjectLength(obj)).toBe(2);
   });
+});
 
-  describe("checkArrayLength", () => {
-    // Positive
-    test('[] should return 0', () => expect(checkArrayLength([])).toBe(0));
-    test('[1,2,3] should return 3', () => expect(checkArrayLength([1,2,3])).toBe(3));
-    test('["a", "b"] should return 2', () => expect(checkArrayLength(["a","b"])).toBe(2));
-    // Negative / Non-array
-    test('{} should return undefined', () => expect(checkArrayLength({})).toBeUndefined());
-    test('42 should return undefined', () => expect(checkArrayLength(42)).toBeUndefined());
-    test('"hello" should return undefined', () => expect(checkArrayLength("hello")).toBeUndefined());
-    test('true should return undefined', () => expect(checkArrayLength(true)).toBeUndefined());
-    test('null should return undefined', () => expect(checkArrayLength(null)).toBeUndefined());
-    test('undefined should return undefined', () => expect(checkArrayLength(undefined)).toBeUndefined());
+describe("Check Is Array Function", () => {
+  test('[] should return true', () => expect(checkIsArray([])).toBe(true));
+  test('[1,2,3] should return true', () => expect(checkIsArray([1,2,3])).toBe(true));
+  test('{} should return false', () => expect(checkIsArray({})).toBe(false));
+  test('42 should return false', () => expect(checkIsArray(42)).toBe(false));
+  test('"hello" should return false', () => expect(checkIsArray("hello")).toBe(false));
+  test('true should return false', () => expect(checkIsArray(true)).toBe(false));
+  test('123n should return false', () => expect(checkIsArray(123n)).toBe(false));
+  test('null should return false', () => expect(checkIsArray(null)).toBe(false));
+  test('undefined should return false', () => expect(checkIsArray(undefined)).toBe(false));
+  test('sparse array should return true', () => expect(checkIsArray([, , ])).toBe(true));
+  test('sparse array should return true', () => expect(checkIsArray([, , ])).toBe(true));
+  test('new Array() should return true', () => expect(checkIsArray(new Array())).toBe(true));
+  test('arguments object should return false', () => {
+    function testFn() {
+      return expect(checkIsArray(arguments)).toBe(false);
+    }
+    testFn(1, 2, 3);
   });
+  test('typed array should return false', () => expect(checkIsArray(new Uint8Array())).toBe(false));
+});
 
+describe("Check Is Array Length Function", () => {
+  test('[] should return 0', () => expect(checkArrayLength([])).toBe(0));
+  test('[1,2,3] should return 3', () => expect(checkArrayLength([1,2,3])).toBe(3));
+  test('["a", "b"] should return 2', () => expect(checkArrayLength(["a","b"])).toBe(2));
+  test('{} should return undefined', () => expect(checkArrayLength({})).toBeUndefined());
+  test('42 should return undefined', () => expect(checkArrayLength(42)).toBeUndefined());
+  test('"hello" should return undefined', () => expect(checkArrayLength("hello")).toBeUndefined());
+  test('true should return undefined', () => expect(checkArrayLength(true)).toBeUndefined());
+  test('null should return undefined', () => expect(checkArrayLength(null)).toBeUndefined());
+  test('undefined should return undefined', () => expect(checkArrayLength(undefined)).toBeUndefined());
+  test('sparse array with 2 empty slots should return 2', () => expect(checkArrayLength([, , ])).toBe(2));
+  test('sparse array with 3 empty slots should return 3', () => expect(checkArrayLength([,,,])).toBe(3));
+  test('nested array should return top-level length only', () => expect(checkArrayLength([[1], [2, 3]])).toBe(2));
+  test('new Array(5) should return 5', () => expect(checkArrayLength(new Array(5))).toBe(5));
+  test('array with holes and values should return correct length', () => expect(checkArrayLength([1, , 3])).toBe(3));
+  test('typed array should return undefined', () => expect(checkArrayLength(new Uint8Array(3))).toBeUndefined());
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phane-js-utils",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Pure JavaScript utility functions",
   "main": "index.js",
   "type": "module",
@@ -12,17 +12,29 @@
     "utils",
     "library"
   ],
+  "homepage": "https://phane-tech.github.io/js-data-type-check/module-DataTypeCheck.html",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phane-tech/js-data-type-check"
+  },
   "author": "Kotipalli Phaneendra Kumar",
   "license": "MIT",
   "scripts": {
-    "docs": "jsdoc -c jsdoc.json",
+    "test": "jest",
     "readme": "npx jsdoc-to-markdown \"js/*.js\" > README.md",
-    "release": "npm run readme && npm version patch && npm publish --access public"
+    "docs": "rimraf docs && npm run test && npx jsdoc -c jsdoc.json",
+    "release": "npm run docs && npm version patch && npm run readme && npm publish --access public"
   },
   "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "babel-jest": "^30.2.0",
     "docdash": "^2.0.2",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
-    "jsdoc-to-markdown": "^9.1.3"
+    "jest-html-reporter": "^4.3.0",
+    "jsdoc": "^4.0.5",
+    "jsdoc-to-markdown": "^9.1.3",
+    "rimraf": "^6.1.2"
   }
 }

package/js/index.js

@@ -1 +0,0 @@
-export * from "./dataTypeCheck.js";