phane-js-utils 1.0.0

package/index.js

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

package/js/dataTypeCheck.js

@@ -0,0 +1,228 @@
+/**
+ * Data Check helpers.
+ * @module DataTypeCheck
+ */
+
+/**
+ * Check if the user input is a number or not.
+ *
+ * @function checkIsNumber
+ * @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
+ *
+ * @example
+ * checkIsNumber(37) => true
+ *
+ * checkIsNumber("hello") => false
+ *
+ * checkIsNumber() => undefined
+ *
+ * checkIsNumber(null) => undefined
+ *
+ */
+export function checkIsNumber(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "number";
+}
+
+/**
+ * Check if the user input is a string or not.
+ *
+ * @function checkIsString
+ * @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
+ *
+ * @example
+ * checkIsString(37) => false
+ *
+ * checkIsString("hello") => true
+ *
+ * checkIsString() => undefined
+ *
+ * checkIsString(null) => undefined
+ *
+ */
+export function checkIsString(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "string";
+}
+
+/**
+ * Check if the user input is a boolean or not.
+ *
+ * @function checkIsBoolean
+ * @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
+ *
+ * @example
+ * checkIsBoolean(37) => false
+ *
+ * checkIsBoolean("hello") => false
+ * 
+ * checkIsBoolean(false) => true
+ *
+ * checkIsBoolean() => undefined
+ *
+ * checkIsBoolean(null) => undefined
+ *
+ */
+export function checkIsBoolean(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "boolean";
+}
+
+/**
+ * Check if the user input is a Bigint or not.
+ *
+ * @function checkIsBigint
+ * @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
+ *
+ * @example
+ * checkIsBigint(37n) => true
+ *
+ * checkIsBigint("hello") => false
+ * 
+ * checkIsBigint(37) => false
+ * 
+ * checkIsBigint() => undefined
+ *
+ * checkIsBigint(null) => undefined
+ */
+export function checkIsBigint(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "bigint";
+}
+
+/**
+ * Check if the user input is a function.
+ *
+ * @function checkIsFunction
+ * @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
+ *
+ * @example
+ * checkIsFunction(function() {}) => true
+ *
+ * checkIsFunction(() => {}) => true
+ *
+ * checkIsFunction(42) => false
+ *
+ * checkIsFunction(null) => undefined
+ *
+ * checkIsFunction()  => undefined
+ */
+export function checkIsFunction(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "function";
+}
+
+/**
+ * Check if the user input is an object.
+ *
+ * @function checkIsObject
+ * @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
+ *
+ * @example
+ * checkIsObject({}) => true
+ *
+ * checkIsObject({ a: 1 }) => true
+ *
+ * checkIsObject([]) => true (arrays are objects in JavaScript)
+ *
+ * checkIsObject(null) => undefined
+ *
+ * checkIsObject(42) => false
+ */
+export function checkIsObject(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return typeof userInput === "object";
+}
+
+/**
+ * Get the number of key-value pairs in an object.
+ *
+ * @function checkObjectLength
+ * @memberof module:DataTypeCheck
+ *
+ * @param {*} userInput - Any value to check
+ * @returns {number|undefined} Number of entries if object, undefined otherwise
+ *
+ * @example
+ * checkObjectLength({ a: 1, b: 2 }) => 2
+ *
+ * checkObjectLength({}) => 0
+ *
+ * checkObjectLength([]) => 0 (arrays are objects in JavaScript)
+ *
+ * checkObjectLength(null) => undefined
+ *
+ * checkObjectLength(42) => undefined
+ */
+export function checkObjectLength(userInput) {
+  if (checkIsObject(userInput)) return Object.entries(userInput)?.length;
+  return undefined;
+}
+
+/**
+ * Check if the user input is an array.
+ *
+ * @function checkIsArray
+ * @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
+ *
+ * @example
+ * checkIsArray([1, 2, 3]) => true
+ *
+ * checkIsArray([]) => true
+ *
+ * checkIsArray({})  => false
+ *
+ * checkIsArray(null) => undefined
+ *
+ * checkIsArray(42) => false
+ */
+export function checkIsArray(userInput) {
+  if (userInput === null || userInput === undefined) return undefined;
+  return Array.isArray(userInput);
+}
+
+/**
+ * Get the length of an array.
+ *
+ * @function checkArrayLength
+ * @memberof module:DataTypeCheck
+ *
+ * @param {*} userInput - Any value to check
+ * @returns {number|undefined} Length of the array if input is an array, undefined otherwise
+ *
+ * @example
+ * checkArrayLength([1, 2, 3])  => 3
+ *
+ * checkArrayLength([]) => 0
+ *
+ * checkArrayLength({}) => undefined
+ *
+ * checkArrayLength(null) => undefined
+ *
+ * checkArrayLength(42) => undefined
+ */
+export function checkArrayLength(userInput) {
+  if (checkIsArray(userInput)) return userInput.length;
+  return undefined;
+}

package/js/dataTypeCheck.test.js

@@ -0,0 +1,163 @@
+import {
+  checkIsNumber,
+  checkIsString,
+  checkIsBoolean,
+  checkIsBigint,
+  checkIsFunction,
+  checkIsObject,
+  checkObjectLength,
+  checkIsArray,
+  checkArrayLength
+} from './dataTypeCheck.js'; 
+
+
+describe("DataTypeCheck Helpers - Comprehensive Tests", () => {
+
+  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("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("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("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("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("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());
+  });
+
+  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());
+  });
+
+  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());
+  });
+
+  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());
+  });
+
+});

package/js/index.js

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

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "phane-js-utils",
+  "version": "1.0.0",
+  "description": "Pure JavaScript utility functions",
+  "main": "index.js",
+  "type": "module",
+  "files": [
+    "js",
+    "doc"
+  ],
+  "keywords": [
+    "javascript",
+    "utils",
+    "library"
+  ],
+  "author": "Kotipalli Phaneendra Kumar",
+  "license": "MIT",
+  "scripts": {
+    "docs": "jsdoc -c jsdoc.json"
+  },
+  "devDependencies": {
+    "docdash": "^2.0.2",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jsdoc": "^4.0.5",
+    "rimraf": "^6.1.2"
+  }
+}