direct-helpers/dist/index.js

Package with basic and daily utilities

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/string/index.ts
var string_exports = {};
__export(string_exports, {
  capitalize: () => capitalize,
  capitalizeWords: () => capitalizeWords,
  countCharacters: () => countCharacters,
  countWords: () => countWords,
  generatePassword: () => generatePassword,
  toCamelCase: () => toCamelCase,
  toKebabCase: () => toKebabCase,
  toSnakeCase: () => toSnakeCase,
  toTitleCase: () => toTitleCase
});
var capitalize = (str) => {
  if (!str) return str;
  return str.charAt(0).toUpperCase() + str.slice(1);
};
var capitalizeWords = (str) => {
  if (!str) return str;
  return str.split(" ").map(capitalize).join(" ");
};
var countWords = (str) => {
  if (!str) return 0;
  return str.split(" ").length;
};
var countCharacters = (str, countWhitespace = false) => {
  if (!str) return 0;
  return countWhitespace ? str.length : str.replace(/\s/g, "").length;
};
var toCamelCase = (str) => {
  if (!str) return str;
  return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
};
var toKebabCase = (str) => {
  if (!str) return str;
  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
};
var toSnakeCase = (str) => {
  if (!str) return str;
  return str.replace(/([A-Z])/g, "_$1").toLowerCase();
};
var toTitleCase = (str) => {
  if (!str) return str;
  return str.replace(/\b\w/g, (char) => char.toUpperCase());
};
var generatePassword = (length, includeSymbols = false) => {
  let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  if (includeSymbols) {
    charset += "!@#$%^&*()_+-=[]{}|;:,.<>?";
  }
  let password = "";
  for (let i = 0; i < length; i++) {
    const randomIndex = Math.floor(Math.random() * charset.length);
    password += charset[randomIndex];
  }
  return password;
};

// src/number/index.ts
var number_exports = {};
__export(number_exports, {
  countPercentage: () => countPercentage,
  cube: () => cube,
  cubeRoot: () => cubeRoot,
  factorial: () => factorial,
  formatNumberWithSuffix: () => formatNumberWithSuffix,
  getOtp: () => getOtp,
  getRandomNumber: () => getRandomNumber,
  isEven: () => isEven,
  isOdd: () => isOdd,
  isPalindrome: () => isPalindrome,
  isPerfectCube: () => isPerfectCube,
  isPerfectSquare: () => isPerfectSquare,
  isPowerOfThree: () => isPowerOfThree,
  isPowerOfTwo: () => isPowerOfTwo,
  isPrime: () => isPrime,
  roundTo: () => roundTo,
  square: () => square,
  squareRoot: () => squareRoot
});
var getRandomNumber = (min, max) => {
  return Math.floor(Math.random() * (max - min + 1)) + min;
};
var getOtp = (length = 6, alphaNumeric = false) => {
  const characters = alphaNumeric ? "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" : "0123456789";
  return Array.from({ length }, () => characters[Math.floor(Math.random() * characters.length)]).join("");
};
var countPercentage = (part, total, precision = 2) => {
  return Number((part / total * 100).toFixed(precision));
};
var isEven = (number) => {
  return number % 2 === 0;
};
var isOdd = (number) => {
  return number % 2 !== 0;
};
var isPrime = (number) => {
  if (number <= 1) return false;
  if (number <= 3) return true;
  if (number % 2 === 0 || number % 3 === 0) return false;
  for (let i = 5; i * i <= number; i += 6) {
    if (number % i === 0 || number % (i + 2) === 0) return false;
  }
  return true;
};
var isPalindrome = (number) => {
  const str = number.toString();
  return str === str.split("").reverse().join("");
};
var isPerfectSquare = (number) => {
  return Number.isInteger(Math.sqrt(number));
};
var isPerfectCube = (number) => {
  return Number.isInteger(Math.cbrt(number));
};
var square = (number) => {
  return number * number;
};
var cube = (number) => {
  return number * number * number;
};
var squareRoot = (number) => {
  return Math.sqrt(number);
};
var cubeRoot = (number) => {
  return Math.cbrt(number);
};
var factorial = (number) => {
  if (number === 0 || number === 1) return 1;
  return number * factorial(number - 1);
};
var isPowerOfTwo = (number) => {
  return (number & number - 1) === 0;
};
var isPowerOfThree = (number) => {
  return (number & number - 1) === 0;
};
var roundTo = (number, precision) => {
  return Number(number.toFixed(precision));
};
var formatNumberWithSuffix = (number, precision) => {
  if (!isFinite(number) || isNaN(number)) {
    return number.toString();
  }
  const resolvedPrecision = Math.max(0, Math.floor(precision));
  const tiers = [
    { threshold: 1e12, divisor: 1e12, suffix: "T" },
    { threshold: 1e9, divisor: 1e9, suffix: "B" },
    { threshold: 1e6, divisor: 1e6, suffix: "M" },
    { threshold: 1e3, divisor: 1e3, suffix: "K" },
    { threshold: 0, divisor: 1, suffix: "" }
  ];
  const absNumber = Math.abs(number);
  const tier = tiers.find((t) => absNumber >= t.threshold);
  if (!tier) {
    return number.toFixed(resolvedPrecision);
  }
  if (number === 0) {
    return number.toFixed(resolvedPrecision);
  }
  const scaledNumber = number / tier.divisor;
  const formattedNumber = scaledNumber.toFixed(resolvedPrecision);
  return formattedNumber + tier.suffix;
};
export {
  number_exports as numberUtils,
  string_exports as stringUtils
};