zen-digital-utils/dist/index.js

A collection of utility functions for JavaScript/TypeScript projects

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  brazilianStates: () => brazilianStates,
  capitalize: () => capitalize,
  capitalizeText: () => capitalizeText,
  chunk: () => chunk,
  deepMerge: () => deepMerge,
  difference: () => difference,
  flatten: () => flatten,
  formatAccountingCurrency: () => formatAccountingCurrency,
  formatBirthdate: () => formatBirthdate,
  formatBranchNumber: () => formatBranchNumber,
  formatBranchNumberWithDefault: () => formatBranchNumberWithDefault,
  formatCountBankNumber: () => formatCountBankNumber,
  formatCpf: () => formatCpf,
  formatCurrency: () => formatCurrency,
  formatCurrencyInput: () => formatCurrencyInput,
  formatCurrencyWithoutSymbol: () => formatCurrencyWithoutSymbol,
  formatDate: () => formatDate,
  formatDateTime: () => formatDateTime,
  formatFullName: () => formatFullName,
  formatInternationalCurrency: () => formatInternationalCurrency,
  formatNumber: () => formatNumber,
  formatPercent: () => formatPercent,
  formatPhoneNumber: () => formatPhoneNumber,
  formatPhoneNumberForWhatsApp: () => formatPhoneNumberForWhatsApp,
  formatTextOnly: () => formatTextOnly,
  formatWithCurrencySymbol: () => formatWithCurrencySymbol,
  formatZipCode: () => formatZipCode,
  formattedDate: () => formattedDate,
  getAcronym: () => getAcronym,
  getDaysBetween: () => getDaysBetween,
  groupBy: () => groupBy,
  hideScroll: () => hideScroll,
  intersection: () => intersection,
  isWeekend: () => isWeekend,
  omit: () => omit,
  parseBrazilianCurrency: () => parseBrazilianCurrency,
  partition: () => partition,
  pick: () => pick,
  shuffle: () => shuffle,
  slugify: () => slugify,
  sortBy: () => sortBy,
  toCents: () => toCents,
  truncate: () => truncate,
  unique: () => unique
});
module.exports = __toCommonJS(index_exports);

// src/utils/states/index.ts
var brazilianStates = [
  { value: "AC", label: "Acre" },
  { value: "AL", label: "Alagoas" },
  { value: "AP", label: "Amap\xE1" },
  { value: "AM", label: "Amazonas" },
  { value: "BA", label: "Bahia" },
  { value: "CE", label: "Cear\xE1" },
  { value: "DF", label: "Distrito Federal" },
  { value: "ES", label: "Esp\xEDrito Santo" },
  { value: "GO", label: "Goi\xE1s" },
  { value: "MA", label: "Maranh\xE3o" },
  { value: "MT", label: "Mato Grosso" },
  { value: "MS", label: "Mato Grosso do Sul" },
  { value: "MG", label: "Minas Gerais" },
  { value: "PA", label: "Par\xE1" },
  { value: "PB", label: "Para\xEDba" },
  { value: "PR", label: "Paran\xE1" },
  { value: "PE", label: "Pernambuco" },
  { value: "PI", label: "Piau\xED" },
  { value: "RJ", label: "Rio de Janeiro" },
  { value: "RN", label: "Rio Grande do Norte" },
  { value: "RS", label: "Rio Grande do Sul" },
  { value: "RO", label: "Rond\xF4nia" },
  { value: "RR", label: "Roraima" },
  { value: "SC", label: "Santa Catarina" },
  { value: "SP", label: "S\xE3o Paulo" },
  { value: "SE", label: "Sergipe" },
  { value: "TO", label: "Tocantins" }
];

// src/utils/dom/hideScroll.ts
function hideScroll(isOpen) {
  if (typeof document === "undefined") return;
  if (isOpen) {
    document.body.classList.add("!overflow-hidden");
  } else {
    document.body.classList.remove("!overflow-hidden");
  }
}

// src/utils/formatters/date/index.ts
function formattedDate(thisDate) {
  if (!thisDate) return "";
  try {
    const dateParts = thisDate.split("-");
    const date = /* @__PURE__ */ new Date(`${dateParts[1]}/${dateParts[2]}/${dateParts[0]}`);
    if (isNaN(date.getTime())) return "";
    const day = String(date.getDate()).padStart(2, "0");
    const month = String(date.getMonth() + 1).padStart(2, "0");
    const year = date.getFullYear();
    return `${day}/${month}/${year}`;
  } catch (error) {
    return "";
  }
}
function formatDate(date, format = "DD/MM/YYYY") {
  if (!(date instanceof Date) || isNaN(date.getTime())) {
    return "";
  }
  const day = String(date.getDate()).padStart(2, "0");
  const month = String(date.getMonth() + 1).padStart(2, "0");
  const year = date.getFullYear();
  return format.replace("YYYY", year.toString()).replace("MM", month).replace("DD", day);
}
function formatDateTime(dateTimeString) {
  if (!dateTimeString) return "";
  const parts = dateTimeString.split(" ");
  if (parts.length !== 2) return dateTimeString;
  const [date, time] = parts;
  return `${date} \u2022 ${time}`;
}
function formatBirthdate(value) {
  if (!value) return "";
  const digits = value.replace(/\D/g, "");
  const day = digits.slice(0, 2);
  const month = digits.slice(2, 4);
  const year = digits.slice(4, 8);
  let formatted = "";
  if (day) {
    formatted += day;
  }
  if (month) {
    formatted += `/${month}`;
  }
  if (year) {
    formatted += `/${year}`;
  }
  return formatted;
}
function getDaysBetween(startDate, endDate) {
  if (!(startDate instanceof Date) || !(endDate instanceof Date) || isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
    return 0;
  }
  const start = new Date(startDate.setHours(0, 0, 0, 0));
  const end = new Date(endDate.setHours(0, 0, 0, 0));
  const diffTime = Math.abs(end.getTime() - start.getTime());
  return Math.floor(diffTime / (1e3 * 60 * 60 * 24));
}
function isWeekend(date) {
  if (!(date instanceof Date) || isNaN(date.getTime())) {
    return false;
  }
  const day = date.getDay();
  return day === 0 || day === 6;
}

// src/utils/formatters/general/index.ts
function capitalize(text) {
  if (!text || typeof text !== "string") return "";
  return text.charAt(0).toUpperCase() + text.slice(1);
}
function capitalizeText(text) {
  if (!text) return "";
  return text.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
}
function slugify(text) {
  if (!text || typeof text !== "string") return "";
  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+|-+$/g, "");
}
function truncate(text, length, suffix = "...") {
  if (!text || typeof text !== "string") return "";
  if (text.length <= length) return text;
  return text.slice(0, length) + suffix;
}
function formatTextOnly(value) {
  if (!value) return "";
  return value.replace(/[^a-zA-ZÀ-ÿ\s]/g, "");
}
function formatFullName(value) {
  if (!value) return "";
  return value.replace(/[^a-záãéêíóõúç\s]/gi, "").replace(/\s+/g, " ").trim();
}
function getAcronym(fullName) {
  if (!fullName) return "";
  const names = fullName.trim().split(" ");
  const firstInitial = names[0] ? names[0][0].toUpperCase() : "";
  const secondInitial = names[1] ? names[1][0].toUpperCase() : "";
  return firstInitial + secondInitial;
}
function formatPercent(value) {
  if (value == null || value === "") {
    return "0,00%";
  }
  let numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return "0,00%";
  }
  numberValue = Math.floor(numberValue * 100) / 100;
  const formattedValue = numberValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
  return `${formattedValue}%`;
}
function formatZipCode(value) {
  if (!value) return "";
  value = value.replace(/\D/g, "");
  value = value.slice(0, 8);
  if (value.length > 5) {
    value = value.replace(/(\d{5})(\d)/, "$1-$2");
  }
  return value;
}

// src/utils/formatters/currency/index.ts
function formatCurrencyInput(value) {
  let numberValue = value == null ? void 0 : value.replace(/\D/g, "");
  if (!value || !numberValue) {
    return "R$ 0,00";
  }
  numberValue = (Number.parseInt(numberValue) / 100).toFixed(2).toString();
  return `R$ ${numberValue.replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".")}`;
}
function formatCurrency(value) {
  if (value == null || value === "") {
    return "R$ 0,00";
  }
  let numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return "R$ 0,00";
  }
  numberValue = Math.floor(numberValue * 100) / 100;
  const formattedValue = numberValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
  return `R$ ${formattedValue}`;
}
function formatWithCurrencySymbol(value, currencySymbol = "$") {
  if (value == null || value === "") {
    return `${currencySymbol} 0.00`;
  }
  let numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return `${currencySymbol} 0.00`;
  }
  numberValue = Math.floor(numberValue * 100) / 100;
  const formattedValue = numberValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
  return `${currencySymbol} ${formattedValue}`;
}
function formatInternationalCurrency(value, locale = "pt-BR", currencyCode = "BRL") {
  if (value == null || value === "") {
    return new Intl.NumberFormat(locale, {
      style: "currency",
      currency: currencyCode
    }).format(0);
  }
  const numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return new Intl.NumberFormat(locale, {
      style: "currency",
      currency: currencyCode
    }).format(0);
  }
  return new Intl.NumberFormat(locale, {
    style: "currency",
    currency: currencyCode
  }).format(numberValue);
}
function formatCurrencyWithoutSymbol(value) {
  if (value == null || value === "") {
    return "0,00";
  }
  let numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return "0,00";
  }
  numberValue = Math.floor(numberValue * 100) / 100;
  return numberValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
}
function formatAccountingCurrency(value) {
  if (value == null || value === "") {
    return "R$ 0,00";
  }
  let numberValue = Number(value);
  if (Number.isNaN(numberValue)) {
    return "R$ 0,00";
  }
  numberValue = Math.floor(numberValue * 100) / 100;
  const isNegative = numberValue < 0;
  const absoluteValue = Math.abs(numberValue);
  const formattedValue = absoluteValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
  return isNegative ? `(R$ ${formattedValue})` : `R$ ${formattedValue}`;
}
function parseBrazilianCurrency(str) {
  str = str.replace(/[^0-9,.-]+/g, "");
  str = str.replace(/\./g, "");
  str = str.replace(",", ".");
  return Number.parseFloat(str);
}
function toCents(value) {
  if (typeof value === "string") {
    return Math.round(parseBrazilianCurrency(value) * 100);
  }
  return Math.round(Number(value) * 100);
}

// src/utils/formatters/numbers/index.ts
function formatPhoneNumberForWhatsApp(value) {
  const cleanValue = value.replace(/\D/g, "");
  return cleanValue;
}
function formatNumber(value) {
  value = value.replace(/\D/g, "");
  return value;
}
function formatPhoneNumber(value) {
  if (!value) {
    return "";
  }
  const valueWithoutMask = value.replace(/\D/g, "");
  const maxLength = 11;
  const limitedValue = valueWithoutMask.slice(0, maxLength);
  if (limitedValue.length > 10) {
    return limitedValue.replace(/^(\d{2})(\d{5})(\d{4})/, "($1) $2-$3");
  }
  if (limitedValue.length > 6) {
    return limitedValue.replace(/^(\d{2})(\d{4})(\d{0,4})/, "($1) $2-$3");
  }
  if (limitedValue.length > 2) {
    return limitedValue.replace(/^(\d{2})(\d{0,5})/, "($1) $2");
  }
  return limitedValue.replace(/^(\d{0,2})/, "($1");
}
function formatCountBankNumber(value) {
  value = value.replace(/\D/g, "");
  value = value.slice(0, 13);
  if (value.length > 12) {
    value = value.replace(/(\d{13})/, "$1");
  }
  return value;
}
function formatBranchNumber(value) {
  value = value.replace(/\D/g, "");
  value = value.slice(0, 5);
  if (value.length > 4) {
    value = value.replace(/(\d{4})(\d)/, "$1-$2");
  }
  return value;
}
function formatBranchNumberWithDefault(value) {
  value = value.replace(/\D/g, "");
  if (value.length === 4) {
    value += "0";
  }
  value = value.slice(0, 5);
  if (value.length > 4) {
    value = value.replace(/(\d{4})(\d)/, "$1-$2");
  }
  return value;
}
function formatCpf(value) {
  value = value.replace(/\D/g, "");
  value = value.slice(0, 11);
  value = value.replace(/(\d{3})(\d)/, "$1.$2");
  value = value.replace(/(\d{3})(\d)/, "$1.$2");
  value = value.replace(/(\d{3})(\d{1,2})$/, "$1-$2");
  return value;
}

// src/utils/objects/index.ts
function deepMerge(target, source) {
  if (!target || typeof target !== "object") return source;
  if (!source || typeof source !== "object") return target;
  const output = __spreadValues({}, target);
  Object.keys(source).forEach((key) => {
    const targetValue = target[key];
    const sourceValue = source[key];
    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
      output[key] = [...targetValue, ...sourceValue];
    } else if (targetValue && typeof targetValue === "object" && sourceValue && typeof sourceValue === "object") {
      output[key] = deepMerge(targetValue, sourceValue);
    } else {
      output[key] = sourceValue !== void 0 ? sourceValue : targetValue;
    }
  });
  return output;
}
function pick(obj, keys) {
  if (!obj || typeof obj !== "object") return {};
  return keys.reduce((result, key) => {
    if (key in obj) {
      result[key] = obj[key];
    }
    return result;
  }, {});
}
function omit(obj, keys) {
  if (!obj || typeof obj !== "object") return {};
  const result = __spreadValues({}, obj);
  keys.forEach((key) => {
    delete result[key];
  });
  return result;
}

// src/utils/arrays/index.ts
function chunk(array, size) {
  if (!Array.isArray(array) || array.length === 0) return [];
  if (size <= 0) return [array];
  const result = [];
  for (let i = 0; i < array.length; i += size) {
    result.push(array.slice(i, i + size));
  }
  return result;
}
function unique(array) {
  if (!Array.isArray(array)) return [];
  return [...new Set(array)];
}
function sortBy(array, key, direction = "asc") {
  if (!Array.isArray(array) || array.length === 0) return [];
  const sorted = [...array].sort((a, b) => {
    const valueA = a[key];
    const valueB = b[key];
    if (typeof valueA === "string" && typeof valueB === "string") {
      return valueA.localeCompare(valueB);
    }
    if (valueA < valueB) return -1;
    if (valueA > valueB) return 1;
    return 0;
  });
  return direction === "desc" ? sorted.reverse() : sorted;
}
function groupBy(array, key) {
  if (!Array.isArray(array)) return {};
  return array.reduce((result, item) => {
    const groupKey = String(item[key]);
    result[groupKey] = result[groupKey] || [];
    result[groupKey].push(item);
    return result;
  }, {});
}
function flatten(array) {
  if (!Array.isArray(array)) return [];
  return array.reduce((result, item) => {
    if (Array.isArray(item)) {
      result.push(...item);
    } else {
      result.push(item);
    }
    return result;
  }, []);
}
function intersection(...arrays) {
  if (!arrays.length || arrays.some((arr) => !Array.isArray(arr))) return [];
  const [first, ...rest] = arrays;
  return first.filter(
    (item) => rest.every((arr) => arr.includes(item))
  );
}
function difference(array, excludeArray) {
  if (!Array.isArray(array)) return [];
  if (!Array.isArray(excludeArray)) return [...array];
  return array.filter((item) => !excludeArray.includes(item));
}
function shuffle(array) {
  if (!Array.isArray(array)) return [];
  const result = [...array];
  for (let i = result.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [result[i], result[j]] = [result[j], result[i]];
  }
  return result;
}
function partition(array, predicate) {
  if (!Array.isArray(array)) return [[], []];
  return array.reduce(
    (result, item) => {
      result[predicate(item) ? 0 : 1].push(item);
      return result;
    },
    [[], []]
  );
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  brazilianStates,
  capitalize,
  capitalizeText,
  chunk,
  deepMerge,
  difference,
  flatten,
  formatAccountingCurrency,
  formatBirthdate,
  formatBranchNumber,
  formatBranchNumberWithDefault,
  formatCountBankNumber,
  formatCpf,
  formatCurrency,
  formatCurrencyInput,
  formatCurrencyWithoutSymbol,
  formatDate,
  formatDateTime,
  formatFullName,
  formatInternationalCurrency,
  formatNumber,
  formatPercent,
  formatPhoneNumber,
  formatPhoneNumberForWhatsApp,
  formatTextOnly,
  formatWithCurrencySymbol,
  formatZipCode,
  formattedDate,
  getAcronym,
  getDaysBetween,
  groupBy,
  hideScroll,
  intersection,
  isWeekend,
  omit,
  parseBrazilianCurrency,
  partition,
  pick,
  shuffle,
  slugify,
  sortBy,
  toCents,
  truncate,
  unique
});