@arkyn/shared 3.0.1-beta.8 → 3.0.1-beta.81

package/src/services/calculateCardInstallment.ts

@@ -1,73 +0,0 @@
-type CalculateCardInstallmentFunction = (props: {
-  cashPrice: number;
-  numberInstallments: number;
-  fees?: number;
-}) => {
-  totalPrice: number;
-  installmentPrice: number;
-};
-
-/**
- * Calculates the installment price and total price for a card payment plan.
- *
- * @remarks
- * **Important:** When the interest amount (`fees`) is equal to 0 or the number of installments (`numberInstallments`) is equal to 1, no interest will be charged.
- *
- * @throws Will throw an error if the number of installments is less than or equal to 0.
- * @throws Will throw an error if the fees are less than 0.
- *
- * @param props - The input parameters for the calculation.
- * @param props.cashPrice - The total cash price of the product or service.
- * @param props.numberInstallments - The number of installments for the payment plan.
- * @param props.fees - The interest rate per installment (default is 0.0349).
- *
- * @returns An object containing:
- * - `totalPrice`: The total price to be paid, rounded to two decimal places.
- * - `installmentPrice`: The price of each installment, rounded to two decimal places.
- *
- * @example
- * ```typescript
- * const result = calculateCardInstallment({
- *   cashPrice: 1000,
- *   numberInstallments: 12,
- *   fees: 0.02,
- * });
- * console.log(result);
- * // Output: { totalPrice: 1124.62, installmentPrice: 93.72 }
- * ```
- */
-
-const calculateCardInstallment: CalculateCardInstallmentFunction = (props) => {
-  const { cashPrice, numberInstallments, fees = 0.0349 } = props;
-
-  if (fees === 0 || numberInstallments === 1) {
-    return {
-      totalPrice: cashPrice,
-      installmentPrice: cashPrice / numberInstallments,
-    };
-  }
-
-  if (numberInstallments <= 0) {
-    throw new Error("Number of installments must be greater than 0");
-  }
-
-  if (fees < 0) {
-    throw new Error("Fees must be greater than or equal to 0");
-  }
-
-  let installmentPrice = 0;
-  let totalPrice = 0;
-
-  let numerator = Math.pow(1 + fees, numberInstallments) * fees;
-  let denominator = Math.pow(1 + fees, numberInstallments) - 1;
-
-  installmentPrice = cashPrice * (numerator / denominator);
-  totalPrice = numberInstallments * installmentPrice;
-
-  return {
-    totalPrice: +totalPrice.toFixed(2),
-    installmentPrice: +installmentPrice.toFixed(2),
-  };
-};
-
-export { calculateCardInstallment };

package/src/services/ensureQuotes.ts

@@ -1,25 +0,0 @@
-type EnsureQuotesFunction = (rawValue: string) => string;
-
-/**
- * Ensures that a given rawValue string is enclosed in quotes.
- *
- * This function checks if the input string is already enclosed in either single
- * quotes (`'`) or double quotes (`"`). If the string is already quoted, it is
- * returned as-is. Otherwise, the function wraps the string in double quotes.
- *
- * @param url - The URL string to be checked and potentially quoted.
- * @returns The input string, either unchanged if it is already quoted, or wrapped in double quotes.
- */
-
-const ensureQuotes: EnsureQuotesFunction = (rawValue) => {
-  const hasSingleQuotes = rawValue.startsWith("'") && rawValue.endsWith("'");
-  const hasDoubleQuotes = rawValue.startsWith('"') && rawValue.endsWith('"');
-
-  if (hasSingleQuotes || hasDoubleQuotes) {
-    return rawValue;
-  }
-
-  return `"${rawValue}"`;
-};
-
-export { ensureQuotes };

package/src/services/maskSensitiveData.ts

@@ -1,68 +0,0 @@
-type MaskSensitiveDataFunction = (
-  jsonString: string,
-  sensitiveKeys?: string[]
-) => string;
-
-/**
- * Masks sensitive data in a JSON string by replacing the values of specified keys with "****".
- *
- * @param jsonString - The JSON string to be processed.
- * @param sensitiveKeys - An array of keys whose values should be masked. Defaults to `["password", "confirmPassword", "creditCard"]`.
- * @returns A JSON string with sensitive data masked. If the input is not a valid JSON string, it returns the original string.
- *
- * @example
- * ```typescript
- * const jsonString = JSON.stringify({
- *   username: "user123",
- *   password: "secret",
- *   profile: {
- *     creditCard: "1234-5678-9012-3456",
- *   },
- * });
- *
- * const result = maskSensitiveData(jsonString, ["password", "creditCard"]);
- * console.log(result);
- * // Output: '{"username":"user123","password":"****","profile":{"creditCard":"****"}}'
- * ```
- */
-
-const maskSensitiveData: MaskSensitiveDataFunction = (
-  jsonString,
-  sensitiveKeys = ["password", "confirmPassword", "creditCard"]
-) => {
-  function maskValue(key: string, value: any): any {
-    if (sensitiveKeys.includes(key)) return "****";
-    return value;
-  }
-
-  function recursiveMask(obj: any): any {
-    if (Array.isArray(obj)) {
-      return obj.map((item) => recursiveMask(item));
-    } else if (obj !== null && typeof obj === "object") {
-      return Object.keys(obj).reduce((acc, key) => {
-        let value = obj[key];
-        if (typeof value === "string") {
-          try {
-            const parsedValue = JSON.parse(value);
-            if (typeof parsedValue === "object") {
-              value = JSON.stringify(recursiveMask(parsedValue));
-            }
-          } catch (e) {}
-        }
-        acc[key] = recursiveMask(maskValue(key, value));
-        return acc;
-      }, {} as any);
-    }
-    return obj;
-  }
-
-  try {
-    const jsonObject = JSON.parse(jsonString);
-    const maskedObject = recursiveMask(jsonObject);
-    return JSON.stringify(maskedObject);
-  } catch (error) {
-    return jsonString;
-  }
-};
-
-export { maskSensitiveData };

package/src/services/removeCurrencySymbols.ts

@@ -1,29 +0,0 @@
-type RemoveCurrencySymbolsFunction = (formattedValue: string) => string;
-
-/**
- * Removes currency symbols from a given formatted string.
- *
- * This function takes a string that may contain currency symbols
- * and removes them using a regular expression. The resulting string
- * is also trimmed of any leading or trailing whitespace.
- *
- * @param formattedValue - The input string containing currency symbols.
- * @returns A string with all currency symbols removed and trimmed of whitespace.
- *
- * @example
- * removeCurrencySymbols("R$13,45"); // "13,45"
- * removeCurrencySymbols("$123.45"); // "123.45"
- * removeCurrencySymbols("€99.99"); // "99.99"
- * removeCurrencySymbols("¥1,000"); // "1,000"
- * removeCurrencySymbols("123.45"); // "123.45" (no symbols to remove)
- */
-
-const removeCurrencySymbols: RemoveCurrencySymbolsFunction = (
-  formattedValue
-) => {
-  return formattedValue
-    .replace(/(?:R\$|\p{Sc}|[$€¥£])/gu, "") // Inclui "R$" e outros símbolos comuns
-    .trim();
-};
-
-export { removeCurrencySymbols };

package/src/services/removeNonNumeric.ts

@@ -1,20 +0,0 @@
-type RemoveNonNumericFunction = (formattedValue: string) => string;
-
-/**
- * Removes all non-numeric characters from a given string.
- *
- * @param prop - The input string from which non-numeric characters will be removed.
- * @returns A new string containing only numeric characters from the input.
- *
- * @example
- * ```typescript
- * const result = removeNonNumeric("abc123def456");
- * console.log(result); // Output: "123456"
- * ```
- */
-
-const removeNonNumeric: RemoveNonNumericFunction = (prop) => {
-  return prop.replace(/[^0-9]/g, "");
-};
-
-export { removeNonNumeric };

package/src/services/stripHtmlTags.ts

@@ -1,20 +0,0 @@
-type StripHtmlTagsFunction = (rawHtml: string) => string;
-
-/**
- * Strips HTML tags from a string.
- *
- * This function removes all HTML tags from the provided string by replacing any content
- * that matches the HTML tag pattern with an empty string.
- *
- * @param rawHtml - The HTML string to be processed
- * @returns The input string with all HTML tags removed
- *
- * @example
- * stripHtmlTags("<p>Hello <strong>World</strong></p>"); // "Hello World"
- */
-
-const stripHtmlTags: StripHtmlTagsFunction = (rawHtml) => {
-  return rawHtml.replace(/<\/?[^>]+(>|$)/g, "");
-};
-
-export { stripHtmlTags };

package/src/services/truncateLargeFields.ts

@@ -1,69 +0,0 @@
-type TruncateLargeFieldsFunction = (
-  jsonString: string,
-  maxLength?: number
-) => string;
-
-/**
- * Truncates large string fields in a JSON string to a specified maximum length.
- *
- * This function parses a JSON string, traverses its structure recursively, and truncates
- * any string fields that exceed the specified maximum length. If a string field is truncated,
- * it is replaced with a message indicating the original length of the field.
- *
- * @param jsonString - The JSON string to process.
- * @param maxLength - The maximum allowed length for string fields. Defaults to 1000.
- * @returns A JSON string with large string fields truncated.
- *
- * @throws {Error} Throws an error if the input is not a valid JSON string.
- *
- * @example
- * ```typescript
- * const json = JSON.stringify({
- *   name: "John",
- *   description: "A very long description that exceeds the maximum length...",
- *   nested: {
- *     details: "Another long string that needs truncation."
- *   }
- * });
- *
- * const result = truncateLargeFields(json, 50);
- * console.log(result);
- * // Output: '{"name":"John","description":"To large information: field as 57 characters","nested":{"details":"To large information: field as 43 characters"}}'
- * ```
- */
-
-const truncateLargeFields: TruncateLargeFieldsFunction = (
-  jsonString,
-  maxLength = 1000
-) => {
-  function truncateValue(value: any): any {
-    if (typeof value === "string" && value.length > maxLength) {
-      return `To large information: field as ${value.length} characters`;
-    }
-    return value;
-  }
-
-  function recursiveTruncate(obj: any): any {
-    if (Array.isArray(obj)) {
-      return obj.map((item) => recursiveTruncate(item)); // Corrigido para processar elementos do array
-    } else if (obj !== null && typeof obj === "object") {
-      return Object.fromEntries(
-        Object.entries(obj).map(([key, value]) => [
-          key,
-          recursiveTruncate(value), // Corrigido para aplicar recursão corretamente
-        ])
-      );
-    }
-    return truncateValue(obj); // Corrigido para truncar valores diretamente
-  }
-
-  try {
-    const parsedJson = JSON.parse(jsonString);
-    const truncatedJson = recursiveTruncate(parsedJson);
-    return JSON.stringify(truncatedJson);
-  } catch (error) {
-    throw new Error("Invalid JSON string");
-  }
-};
-
-export { truncateLargeFields };

package/src/validations/validateCep.ts

@@ -1,41 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type ValidateCepFunction = (rawCep: string) => boolean;
-
-/**
- * Removes all non-digit characters from the CEP.
- * @param cep - Raw CEP string.
- * @returns Only numeric characters.
- */
-
-/**
- * Validates a Brazilian CEP (Código de Endereçamento Postal).
- *
- * A valid CEP has 8 numeric digits.
- *
- * @param rawCep - CEP string, may include formatting (e.g., "12345-678").
- * @returns `true` if the CEP is valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validateCep("12345-678"); // true
- * validateCep("12345678");  // true
- * validateCep("ABCDE-123"); // false
- * ```
- */
-
-const validateCep: ValidateCepFunction = (rawCep) => {
-  if (!rawCep) return false;
-
-  const validFormat = /^[0-9-]+$/.test(rawCep);
-  if (!validFormat) return false;
-
-  const cep = removeNonNumeric(rawCep);
-
-  const CEP_LENGTH = 8;
-  const isOnlyDigits = /^\d{8}$/.test(cep);
-
-  return cep.length === CEP_LENGTH && isOnlyDigits;
-};
-
-export { validateCep };

package/src/validations/validateCnpj.ts

@@ -1,65 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type ValidateCnpjFunction = (rawCnpj: string) => boolean;
-
-function isInvalidLength(cnpj: string) {
-  const CNPJ_LENGTH = 14;
-  return cnpj.length !== CNPJ_LENGTH;
-}
-
-function hasAllDigitsEqual(cnpj: string) {
-  const [firstDigit] = cnpj;
-  return [...cnpj].every((digit) => digit === firstDigit);
-}
-
-function calculateDigit(cnpj: string, multipliers: number[]) {
-  let total = 0;
-  for (let i = 0; i < multipliers.length; i++) {
-    total += parseInt(cnpj[i]) * multipliers[i];
-  }
-  const rest = total % 11;
-  return rest < 2 ? 0 : 11 - rest;
-}
-
-function extractDigit(cnpj: string) {
-  return cnpj.slice(12);
-}
-
-/**
- * Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number.
- *
- * This function performs:
- * - Sanitization (removes non-digit characters).
- * - Length check (must be 14 digits).
- * - Repeating digits check (invalid if all digits are the same).
- * - Verifies the two check digits with the proper weights.
- *
- * @param rawCnpj - CNPJ string, possibly formatted.
- * @returns `true` if valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validateCnpj("12.345.678/0001-95"); // false
- * validateCnpj("11.444.777/0001-61"); // true
- * ```
- */
-
-const validateCnpj: ValidateCnpjFunction = (rawCnpj) => {
-  if (!rawCnpj) return false;
-
-  const cnpj = removeNonNumeric(rawCnpj);
-
-  if (isInvalidLength(cnpj)) return false;
-  if (hasAllDigitsEqual(cnpj)) return false;
-
-  const base = cnpj.slice(0, 12);
-  const digit1 = calculateDigit(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
-  const digit2 = calculateDigit(
-    base + digit1,
-    [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
-  );
-
-  return extractDigit(cnpj) === `${digit1}${digit2}`;
-};
-
-export { validateCnpj };

package/src/validations/validateCpf.ts

@@ -1,62 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type ValidateCpfFunction = (rawCpf: string) => boolean;
-
-function isInvalidLength(cpf: string) {
-  const CPF_LENGTH = 11;
-  return cpf.length !== CPF_LENGTH;
-}
-
-function hasAllDigitsEqual(cpf: string) {
-  const [firstCpfDigit] = cpf;
-  return [...cpf].every((digit) => digit === firstCpfDigit);
-}
-
-function calculateDigit(cpf: string, factor: number) {
-  let total = 0;
-  for (const digit of cpf) {
-    if (factor > 1) total += parseInt(digit) * factor--;
-  }
-  const rest = total % 11;
-  return rest < 2 ? 0 : 11 - rest;
-}
-
-function extractDigit(cpf: string) {
-  return cpf.slice(9);
-}
-
-/**
- * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
- *
- * The CPF is a unique identifier assigned to Brazilian citizens and residents.
- * This function checks if the provided CPF is valid by performing the following steps:
- * - Removes any non-digit characters from the input.
- * - Verifies if the CPF has the correct length (11 digits).
- * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
- * - Calculates the first and second verification digits using the CPF algorithm.
- * - Compares the calculated verification digits with the ones provided in the CPF.
- *
- * @param rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
- * @returns `true` if the CPF is valid, otherwise `false`.
- *
- * @example
- * ```typescript
- * validateCpf("123.456.789-09"); // false
- * validateCpf("111.444.777-35"); // true
- * ```
- */
-
-const validateCpf: ValidateCpfFunction = (rawCpf) => {
-  if (!rawCpf) return false;
-  const cpf = removeNonNumeric(rawCpf);
-
-  if (isInvalidLength(cpf)) return false;
-  if (hasAllDigitsEqual(cpf)) return false;
-
-  const digit1 = calculateDigit(cpf, 10);
-  const digit2 = calculateDigit(cpf, 11);
-
-  return extractDigit(cpf) === `${digit1}${digit2}`;
-};
-
-export { validateCpf };

package/src/validations/validateDate.ts

@@ -1,86 +0,0 @@
-type ValidateDateConfig = {
-  inputFormat?: "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
-  minYear?: number;
-  maxYear?: number;
-};
-
-type ValidateDateFunction = (
-  rawDate: string,
-  config?: ValidateDateConfig
-) => boolean;
-
-/**
- * Validates a date string based on the provided format and configuration.
- *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
- *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
- *
- * @example
- * ```typescript
- * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
- * ```
- */
-
-const validateDate: ValidateDateFunction = (rawDate, config) => {
-  let day: string, month: string, year: string;
-
-  const inputFormat = config?.inputFormat || "DD/MM/YYYY";
-  const minYear = config?.minYear || 1900;
-  const maxYear = config?.maxYear || 3000;
-
-  if (inputFormat === "DD/MM/YYYY") {
-    const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
-    if (!dateRegex.test(rawDate)) return false;
-    [, day, month, year] = rawDate.match(dateRegex) || [];
-  } else if (inputFormat === "MM-DD-YYYY") {
-    const dateRegex = /^(\d{2})-(\d{2})-(\d{4})$/;
-    if (!dateRegex.test(rawDate)) return false;
-    [, month, day, year] = rawDate.match(dateRegex) || [];
-  } else if (inputFormat === "YYYY-MM-DD") {
-    const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
-    if (!dateRegex.test(rawDate)) return false;
-    [, year, month, day] = rawDate.match(dateRegex) || [];
-  } else {
-    throw new Error("Invalid date format");
-  }
-
-  const dayNum = parseInt(day, 10);
-  const monthNum = parseInt(month, 10);
-  const yearNum = parseInt(year, 10);
-
-  if (dayNum < 1 || dayNum > 31) return false;
-  if (monthNum < 1 || monthNum > 12) return false;
-
-  const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-
-  if (monthNum === 2) {
-    const isLeapYear =
-      (yearNum % 4 === 0 && yearNum % 100 !== 0) || yearNum % 400 === 0;
-    if (dayNum > (isLeapYear ? 29 : 28)) return false;
-  } else if (dayNum > daysInMonth[monthNum - 1]) {
-    return false;
-  }
-
-  if (yearNum < minYear || yearNum > maxYear) return false;
-
-  const isValidDate =
-    new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
-
-  return isValidDate;
-};
-
-export { validateDate };

package/src/validations/validatePassword.ts

@@ -1,41 +0,0 @@
-type ValidatePasswordFunction = (rawPassword: string) => boolean;
-
-/**
- * Validates a password based on the following rules:
- * - At least 8 characters
- * - At least 1 uppercase letter
- * - At least 1 letter (any case)
- * - At least 1 number
- * - At least 1 special character
- *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validatePassword("Senha@123"); // true
- * validatePassword("senha123");  // false (no uppercase, no special char)
- * ```
- */
-
-const validatePassword: ValidatePasswordFunction = (rawPassword) => {
-  if (!rawPassword) return false;
-
-  const hasMinLength = rawPassword.length >= 8;
-  const hasUppercase = /[A-Z]/.test(rawPassword);
-  const hasLetter = /[a-z]/.test(rawPassword);
-  const hasNumber = /\d/.test(rawPassword);
-  const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>_\-+=~`[\]\\\/]/.test(
-    rawPassword
-  );
-
-  return [
-    hasMinLength,
-    hasUppercase,
-    hasLetter,
-    hasNumber,
-    hasSpecialChar,
-  ].every((condition) => condition);
-};
-
-export { validatePassword };

package/src/validations/validatePhone.ts

@@ -1,50 +0,0 @@
-import { countries } from "@arkyn/templates";
-
-type ValidatePhoneFunction = (rawPhone: string) => boolean;
-
-/**
- * Validates a phone number against a list of country-specific formats.
- *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
- *
- * @example
- * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
- * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
- * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
- * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
- * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
- * ```
- */
-
-const validatePhone: ValidatePhoneFunction = (rawPhone) => {
-  for (const country of countries) {
-    const countryCode = country.code;
-    const prefix = country.prefix ? `-${country.prefix}` : "";
-    const digitCount = country.mask.replace(/[^_]/g, "").length;
-
-    if (country.iso === "BR") {
-      const brazilRegex = new RegExp(`^\\${countryCode} \\d{2}9?\\d{8}$`);
-      if (brazilRegex.test(rawPhone)) return true;
-      continue;
-    }
-
-    const regex = new RegExp(`^\\${countryCode}${prefix} \\d{${digitCount}}$`);
-    if (regex.test(rawPhone)) return true;
-  }
-
-  return false;
-};
-
-export { validatePhone };