js-utils-core 1.0.1

package/arrayUtils.js

@@ -0,0 +1,116 @@
+/**
+ * Array utilities with clean, composable functions
+ */
+
+/**
+ * Get the first element or n elements from an array
+ */
+const head = (arr, n = 1) => {
+  if (n === 1) return arr[0];
+  return arr.slice(0, n);
+};
+
+/**
+ * Get the last element or n elements from an array
+ */
+const tail = (arr, n = 1) => {
+  if (n === 1) return arr[arr.length - 1];
+  return arr.slice(-n);
+};
+
+/**
+ * Flatten array by one level or completely
+ */
+const flatten = (arr, depth = Infinity) => {
+  return arr.reduce((acc, val) => {
+    if (Array.isArray(val) && depth > 0) {
+      acc.push(...flatten(val, depth - 1));
+    } else {
+      acc.push(val);
+    }
+    return acc;
+  }, []);
+};
+
+/**
+ * Remove duplicate values, keeping first occurrence
+ */
+const unique = (arr, key = null) => {
+  if (!key) return [...new Set(arr)];
+  const seen = new Set();
+  return arr.filter((item) => {
+    const keyVal = key(item);
+    if (seen.has(keyVal)) return false;
+    seen.add(keyVal);
+    return true;
+  });
+};
+
+/**
+ * Group array elements by a key function
+ */
+const groupBy = (arr, key) => {
+  return arr.reduce((acc, item) => {
+    const k = typeof key === "function" ? key(item) : item[key];
+    if (!acc[k]) acc[k] = [];
+    acc[k].push(item);
+    return acc;
+  }, {});
+};
+
+/**
+ * Create chunks of specified size
+ */
+const chunk = (arr, size) => {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+};
+
+/**
+ * Find the minimum or maximum value
+ */
+const minBy = (arr, key) => {
+  return arr.reduce((min, item) => (key(item) < key(min) ? item : min));
+};
+
+const maxBy = (arr, key) => {
+  return arr.reduce((max, item) => (key(item) > key(max) ? item : max));
+};
+
+/**
+ * Sum array values
+ */
+const sum = (arr, key = null) => {
+  return arr.reduce((acc, item) => {
+    const val = key ? key(item) : item;
+    return acc + (typeof val === "number" ? val : 0);
+  }, 0);
+};
+
+/**
+ * Deep clone an object or array
+ */
+
+const deepClone = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  return structuredClone(obj);
+};
+
+module.exports = {
+  head,
+  tail,
+  flatten,
+  unique,
+  groupBy,
+  chunk,
+  minBy,
+  maxBy,
+  sum,
+  deepClone,
+};

package/index.js

@@ -0,0 +1,27 @@
+/**
+ * JS Utils - A clean utility library
+ * Inspired by lodash and radash with modern, functional approach
+ */
+
+const arrayUtils = require("./arrayUtils");
+const objectUtils = require("./objectUtils");
+const stringUtils = require("./stringUtils");
+const typeUtils = require("./typeUtils");
+const mathUtils = require("./mathUtils");
+
+module.exports = {
+  // Array utilities
+  ...arrayUtils,
+
+  // Object utilities
+  ...objectUtils,
+
+  // String utilities
+  ...stringUtils,
+
+  // Type utilities
+  ...typeUtils,
+
+  // Math utilities
+  ...mathUtils,
+};

package/mathUtils.js

@@ -0,0 +1,133 @@
+/**
+ * Math utilities for common calculations
+ */
+
+/**
+ * Calculate average of numbers
+ */
+const average = (numbers) => {
+  if (numbers.length === 0) return 0;
+  return numbers.reduce((a, b) => a + b, 0) / numbers.length;
+};
+
+/**
+ * Calculate sum of numbers
+ */
+const sum = (numbers) => {
+  return numbers.reduce((a, b) => a + b, 0);
+};
+
+/**
+ * Find minimum value
+ */
+const min = (...numbers) => {
+  return Math.min(...numbers);
+};
+
+/**
+ * Find maximum value
+ */
+const max = (...numbers) => {
+  return Math.max(...numbers);
+};
+
+/**
+ * Clamp value between min and max
+ */
+const clamp = (value, min, max) => {
+  return Math.max(min, Math.min(value, max));
+};
+
+/**
+ * Round to n decimal places
+ */
+const round = (num, decimals = 0) => {
+  return Math.round(num * Math.pow(10, decimals)) / Math.pow(10, decimals);
+};
+
+/**
+ * Calculate percentage
+ */
+const percentage = (value, total) => {
+  return (value / total) * 100;
+};
+
+/**
+ * Calculate percentage of value
+ */
+const percentageOf = (percent, total) => {
+  return (percent / 100) * total;
+};
+
+/**
+ * Check if number is even
+ */
+const isEven = (num) => {
+  return num % 2 === 0;
+};
+
+/**
+ * Check if number is odd
+ */
+const isOdd = (num) => {
+  return num % 2 !== 0;
+};
+
+/**
+ * Check if number is prime
+ */
+const isPrime = (num) => {
+  if (num <= 1) return false;
+  if (num <= 3) return true;
+  if (num % 2 === 0 || num % 3 === 0) return false;
+  for (let i = 5; i * i <= num; i += 6) {
+    if (num % i === 0 || num % (i + 2) === 0) return false;
+  }
+  return true;
+};
+
+/**
+ * Generate random number between min and max
+ */
+const random = (min = 0, max = 1) => {
+  return Math.random() * (max - min) + min;
+};
+
+/**
+ * Generate random integer between min and max (inclusive)
+ */
+const randomInt = (min, max) => {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+/**
+ * Calculate absolute difference
+ */
+const difference = (a, b) => {
+  return Math.abs(a - b);
+};
+
+/**
+ * Check if two numbers are approximately equal
+ */
+const approximatelyEqual = (a, b, tolerance = 0.0001) => {
+  return Math.abs(a - b) < tolerance;
+};
+
+module.exports = {
+  average,
+  sum,
+  min,
+  max,
+  clamp,
+  round,
+  percentage,
+  percentageOf,
+  isEven,
+  isOdd,
+  isPrime,
+  random,
+  randomInt,
+  difference,
+  approximatelyEqual,
+};

package/objectUtils.js

@@ -0,0 +1,144 @@
+/**
+ * Object utilities with functional approach
+ */
+
+/**
+ * Deep clone using structuredClone or fallback
+ */
+const clone = (obj) => {
+  if (typeof structuredClone === "function") {
+    return structuredClone(obj);
+  }
+  // Fallback for older environments
+  return JSON.parse(JSON.stringify(obj));
+};
+
+/**
+ * Pick specified keys from object
+ */
+const pick = (obj, keys) => {
+  return keys.reduce((acc, key) => {
+    if (key in obj) acc[key] = obj[key];
+    return acc;
+  }, {});
+};
+
+/**
+ * Omit specified keys from object
+ */
+const omit = (obj, keys) => {
+  const keySet = new Set(keys);
+  return Object.entries(obj).reduce((acc, [key, val]) => {
+    if (!keySet.has(key)) acc[key] = val;
+    return acc;
+  }, {});
+};
+
+/**
+ * Merge multiple objects (shallow)
+ */
+const merge = (...objects) => {
+  return Object.assign({}, ...objects);
+};
+
+/**
+ * Deep merge objects
+ */
+const deepMerge = (target, ...sources) => {
+  if (!sources.length) return target;
+
+  const result = clone(target);
+
+  for (const source of sources) {
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        if (isPlainObject(source[key]) && isPlainObject(result[key])) {
+          result[key] = deepMerge(result[key], source[key]);
+        } else {
+          result[key] = source[key];
+        }
+      }
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Check if value is a plain object
+ */
+const isPlainObject = (val) => {
+  return val !== null && typeof val === "object" && val.constructor === Object;
+};
+
+/**
+ * Flatten nested object with dot notation
+ */
+const flatten = (obj, prefix = "") => {
+  const result = {};
+
+  const traverse = (current, key) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+
+    if (isPlainObject(current[key]) && Object.keys(current[key]).length > 0) {
+      traverse(current[key], "");
+      for (const k in current[key]) {
+        traverse(current[key], k);
+      }
+    } else {
+      result[newKey] = current[key];
+    }
+  };
+
+  for (const key in obj) {
+    traverse(obj, key);
+  }
+
+  return result;
+};
+
+/**
+ * Get nested object value safely
+ */
+const get = (obj, path, defaultValue = undefined) => {
+  const keys = path.split(".");
+  let result = obj;
+
+  for (const key of keys) {
+    if (result == null) return defaultValue;
+    result = result[key];
+  }
+
+  return result !== undefined ? result : defaultValue;
+};
+
+/**
+ * Set nested object value
+ */
+const set = (obj, path, value) => {
+  const keys = path.split(".");
+  let current = obj;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+  return obj;
+};
+
+module.exports = {
+  clone,
+  pick,
+  omit,
+  merge,
+  deepMerge,
+  isPlainObject,
+  flatten,
+  get,
+  set,
+};

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "js-utils-core",
+  "version": "1.0.1",
+  "description": "A lightweight collection of reusable JavaScript utility functions designed to simplify everyday development tasks and promote clean, consistent code.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Manasa",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/stringUtils.js

@@ -0,0 +1,121 @@
+/**
+ * String utilities with common transformations
+ */
+
+/**
+ * Convert string to camelCase
+ */
+const camelCase = (str) => {
+  return str
+    .replace(/[-_\s](.)/g, (_, char) => char.toUpperCase())
+    .replace(/^(.)/, (char) => char.toLowerCase());
+};
+
+/**
+ * Convert string to snake_case
+ */
+const snakeCase = (str) => {
+  return str
+    .replace(/([A-Z])/g, "_$1")
+    .replace(/[-\s]/g, "_")
+    .toLowerCase()
+    .replace(/^_/, "");
+};
+
+/**
+ * Convert string to PascalCase
+ */
+const pascalCase = (str) => {
+  return str
+    .split(/[-_\s]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+};
+
+/**
+ * Convert string to kebab-case
+ */
+const kebabCase = (str) => {
+  return str
+    .replace(/([A-Z])/g, "-$1")
+    .replace(/[-_\s]+/g, "-")
+    .toLowerCase()
+    .replace(/^-/, "");
+};
+
+/**
+ * Capitalize first letter
+ */
+const capitalize = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+/**
+ * Repeat string n times
+ */
+const repeat = (str, n) => {
+  return str.repeat(Math.max(0, n));
+};
+
+/**
+ * Pad string to desired length
+ */
+const padStart = (str, length, padString = " ") => {
+  return String(str).padStart(length, padString);
+};
+
+const padEnd = (str, length, padString = " ") => {
+  return String(str).padEnd(length, padString);
+};
+
+/**
+ * Truncate string with ellipsis
+ */
+const truncate = (str, length, suffix = "...") => {
+  if (str.length <= length) return str;
+  return str.slice(0, length - suffix.length) + suffix;
+};
+
+/**
+ * Check if string starts with prefix
+ */
+const startsWith = (str, prefix) => {
+  return String(str).startsWith(prefix);
+};
+
+/**
+ * Check if string ends with suffix
+ */
+const endsWith = (str, suffix) => {
+  return String(str).endsWith(suffix);
+};
+
+/**
+ * Remove whitespace from both ends
+ */
+const trim = (str) => {
+  return String(str).trim();
+};
+
+/**
+ * Reverse a string
+ */
+const reverse = (str) => {
+  return String(str).split("").reverse().join("");
+};
+
+module.exports = {
+  camelCase,
+  snakeCase,
+  pascalCase,
+  kebabCase,
+  capitalize,
+  repeat,
+  padStart,
+  padEnd,
+  truncate,
+  startsWith,
+  endsWith,
+  trim,
+  reverse,
+};

package/typeUtils.js

@@ -0,0 +1,101 @@
+/**
+ * Type checking utilities
+ */
+
+/**
+ * Get exact type of value
+ */
+const typeOf = (val) => {
+  if (val === null) return "null";
+  if (val === undefined) return "undefined";
+  if (Array.isArray(val)) return "array";
+  if (val instanceof Date) return "date";
+  if (val instanceof RegExp) return "regexp";
+  if (val instanceof Map) return "map";
+  if (val instanceof Set) return "set";
+  return typeof val;
+};
+
+/**
+ * Check if value is null or undefined
+ */
+const isEmpty = (val) => {
+  if (val === null || val === undefined) return true;
+  if (typeof val === "string" || Array.isArray(val)) return val.length === 0;
+  if (val instanceof Map || val instanceof Set) return val.size === 0;
+  if (typeof val === "object") return Object.keys(val).length === 0;
+  return false;
+};
+
+/**
+ * Check if value is truthy (not empty, null, undefined, false, 0, NaN)
+ */
+const isTruthy = (val) => {
+  return !!val && !isEmpty(val);
+};
+
+/**
+ * Check various types
+ */
+const isNull = (val) => val === null;
+const isUndefined = (val) => val === undefined;
+const isBoolean = (val) => typeof val === "boolean";
+const isNumber = (val) => typeof val === "number" && !isNaN(val);
+const isString = (val) => typeof val === "string";
+const isFunction = (val) => typeof val === "function";
+const isObject = (val) => val !== null && typeof val === "object";
+const isArray = (val) => Array.isArray(val);
+const isDate = (val) => val instanceof Date && !isNaN(val.getTime());
+const isRegExp = (val) => val instanceof RegExp;
+const isMap = (val) => val instanceof Map;
+const isSet = (val) => val instanceof Set;
+
+/**
+ * Check if value is a plain object (not array, Date, etc.)
+ */
+const isPlainObject = (val) => {
+  return val !== null && typeof val === "object" && val.constructor === Object;
+};
+
+/**
+ * Check if value is numeric (including string numbers)
+ */
+const isNumeric = (val) => {
+  return !isNaN(val) && !isNaN(parseFloat(val));
+};
+
+/**
+ * Check if value is integer
+ */
+const isInteger = (val) => {
+  return Number.isInteger(val);
+};
+
+/**
+ * Check if value is finite number
+ */
+const isFinite = (val) => {
+  return Number.isFinite(val);
+};
+
+module.exports = {
+  typeOf,
+  isEmpty,
+  isTruthy,
+  isNull,
+  isUndefined,
+  isBoolean,
+  isNumber,
+  isString,
+  isFunction,
+  isObject,
+  isArray,
+  isDate,
+  isRegExp,
+  isMap,
+  isSet,
+  isPlainObject,
+  isNumeric,
+  isInteger,
+  isFinite,
+};