@arkyn/shared 3.0.1-beta.21 → 3.0.1-beta.23

package/src/formats/formatToPhone.ts

@@ -1,170 +0,0 @@
-import { countries } from "@arkyn/templates";
-
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type CountryType = {
-  name: string;
-  code: string;
-  iso: string;
-  prefix: null | string;
-  flag: string;
-  mask: string;
-};
-
-type FormatToPhoneFunction = (prop: string) => string;
-
-function getMask(value: string): "NINE" | "EIGTH" {
-  const mask = value.length > 10 ? "NINE" : "EIGTH";
-  return mask;
-}
-
-const TYPES = {
-  EIGTH: "(99) 9999-9999",
-  NINE: "(99) 99999-9999",
-};
-
-const MAX_LENGTH = removeNonNumeric(TYPES.NINE).length;
-
-function applyMask(value: string, maskPattern: string) {
-  let result = "";
-  let digitIndex = 0;
-
-  for (let i = 0; i < maskPattern.length; i++) {
-    if (maskPattern[i] === "9") {
-      if (digitIndex < value.length) {
-        result += value[digitIndex];
-        digitIndex++;
-      } else {
-        break;
-      }
-    } else {
-      if (digitIndex < value.length) {
-        result += maskPattern[i];
-      } else {
-        break;
-      }
-    }
-  }
-
-  return result;
-}
-
-function formatPhoneNumber(phoneNumber: string, country: CountryType): string {
-  if (country.code === "+55") {
-    let value = removeNonNumeric(phoneNumber);
-    const mask = getMask(value);
-
-    let nextLength = value.length;
-    if (nextLength > MAX_LENGTH) return value;
-
-    value = applyMask(value, TYPES[mask] as "EIGTH" | "NINE");
-    return value;
-  }
-
-  const mask = country.mask;
-  let formattedNumber = mask;
-
-  if (country.prefix) {
-    const prefixRegex = /\$+/g;
-    formattedNumber = formattedNumber.replace(prefixRegex, country.prefix);
-  }
-
-  for (
-    let i = 0, j = 0;
-    i < formattedNumber.length && j < phoneNumber.length;
-    i++
-  ) {
-    if (formattedNumber[i] === "_") {
-      formattedNumber =
-        formattedNumber.substring(0, i) +
-        phoneNumber[j] +
-        formattedNumber.substring(i + 1);
-      j++;
-    }
-  }
-
-  return formattedNumber;
-}
-
-function getCountryWithPrefixCode(countryCode: string, prefix: string) {
-  const country = countries.find(
-    (country) => country.code === countryCode && country.prefix === prefix
-  );
-
-  if (!country) throw new Error("Invalid country code or prefix");
-
-  if (country.prefix !== prefix) {
-    throw new Error("Invalid country code or prefix");
-  }
-
-  if (!country.prefix) {
-    throw new Error("Invalid country code or prefix");
-  }
-  return country;
-}
-
-function getCountryWithoutPrefixCode(countryCode: string) {
-  const country = countries.find((country) => country.code === countryCode);
-  if (!country) throw new Error("Invalid country code");
-  if (country.prefix) throw new Error("Invalid country code");
-  return country;
-}
-
-/**
- * Formats a phone number string based on the provided country code and optional prefix.
- *
- * The input string should follow the format: `"<countryCode>-<prefix> <phoneNumber>"` or `"<countryCode> <phoneNumber>"`.
- * The function determines the appropriate formatting mask based on the country and applies it to the phone number.
- *
- * @param prop - The phone number string to be formatted. It must include the country code and optionally a prefix.
- *               Example formats:
- *               - "+55 32912345678"
- *               - "+1 1234567890"
- *
- * @returns The formatted phone number string based on the country's formatting rules.
- *
- * @throws {Error} If the input phone number does not match the expected format.
- * @throws {Error} If the country code or phone number is missing from the input string.
- * @throws {Error} If the provided country code and prefix combination is invalid.
- * @throws {Error} If the provided country code is invalid.
- * @throws {Error} If the provided country code has a prefix but none is supplied in the input.
- *
- * @example
- * ```typescript
- * import { formatToPhone } from "./formatToPhone";
- *
- * const formattedPhone1 = formatToPhone("+55 11912345678");
- * console.log(formattedPhone1); // Output: "(11) 91234-5678" (brazilian phone number format)
- *
- * const formattedPhone2 = formatToPhone("+1-123 4567890");
- * console.log(formattedPhone2); // Output: "(123) 456-7890" (us phone number format)
- * ```
- */
-
-const formatToPhone: FormatToPhoneFunction = (prop) => {
-  const phoneRegex = /^\+\d{1,4}(-\d{1,4})? \d+$/;
-
-  if (!phoneRegex.test(prop)) {
-    throw new Error(
-      "Invalid phone number format. Expected format: +<countryCode>-<optionalPrefix> <phoneNumber>"
-    );
-  }
-
-  const countryCode = prop.split(" ")[0].split("-")[0];
-  const prefixCode = prop.split(" ")[0].split("-")[1];
-  const phoneNumber = prop.split(" ")[1];
-
-  if (!countryCode || !phoneNumber) {
-    throw new Error("Invalid phone number format");
-  }
-
-  if (prefixCode) {
-    const country = getCountryWithPrefixCode(countryCode, prefixCode);
-    return formatPhoneNumber(phoneNumber, country);
-  }
-
-  const country = getCountryWithoutPrefixCode(countryCode);
-  return formatPhoneNumber(phoneNumber, country);
-};
-
-export { formatToPhone };

package/src/generators/generateColorByString.ts

@@ -1,33 +0,0 @@
-type GenerateColorByStringFunction = (prop: string) => string;
-
-/**
- * Generates a hexadecimal color code based on the input string.
- * The function creates a hash from the string and uses it to calculate
- * RGB values, which are then converted to a hexadecimal color code.
- *
- * @param prop - The input string used to generate the color.
- * @returns A hexadecimal color code (e.g., "#a1b2c3") derived from the input string.
- * @example
- * const color = generateColorByString("example");
- * console.log(color); // Outputs a consistent hex color like "#5e8f9a"
- */
-
-const generateColorByString: GenerateColorByStringFunction = (prop) => {
-  var hash = 0;
-
-  for (var i = 0; i < prop.length; i++) {
-    hash = prop.charCodeAt(i) + ((hash << 5) - hash);
-  }
-
-  var red = (hash & 0xff0000) >> 16;
-  var green = (hash & 0x00ff00) >> 8;
-  var blue = hash & 0x0000ff;
-
-  var redHex = red.toString(16).padStart(2, "0");
-  var greenHex = green.toString(16).padStart(2, "0");
-  var blueHex = blue.toString(16).padStart(2, "0");
-
-  return "#" + redHex + greenHex + blueHex;
-};
-
-export { generateColorByString };

package/src/generators/generateId.ts

@@ -1,61 +0,0 @@
-import { v4, v7 } from "uuid";
-
-function hexToBin(hex: string) {
-  hex = hex.replace(/-/g, "");
-  const buffer = new Uint8Array(hex.length / 2);
-
-  for (let i = 0; i < hex.length; i += 2) {
-    buffer[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-  }
-
-  return buffer;
-}
-
-function uuidV4() {
-  const uuid = v4();
-  return { text: uuid, binary: hexToBin(uuid) };
-}
-
-function uuidV7() {
-  const uuid = v7();
-  return { text: uuid, binary: hexToBin(uuid) };
-}
-
-/**
- * Generates a unique identifier (UUID) in the specified format and type.
- *
- * @param type - The desired output type of the UUID. Can be:
- *   - `"text"`: Returns the UUID as a string.
- *   - `"binary"`: Returns the UUID as a `Uint8Array` in binary format.
- * @param format - The version of the UUID to generate. Can be:
- *   - `"v4"`: Generates a random UUID (version 4).
- *   - `"v7"`: Generates a time-ordered UUID (version 7).
- * @returns The generated UUID in the specified type and format.
- *   - If `type` is `"text"`, a string representation of the UUID is returned.
- *   - If `type` is `"binary"`, a `Uint8Array` representation of the UUID is returned.
- * @throws {Error} If an invalid `type` or `format` is provided.
- *
- * @example
- * // Generate a version 4 UUID as a string
- * const idTextV4 = generateId("text", "v4");
- * console.log(idTextV4); // e.g., "550e8400-e29b-41d4-a716-446655440000"
- *
- * @example
- * // Generate a version 7 UUID as binary
- * const idBinaryV7 = generateId("binary", "v7");
- * console.log(idBinaryV7); // Uint8Array([...])
- */
-function generateId(type: "text", format: "v4" | "v7"): string;
-function generateId(type: "binary", format: "v4" | "v7"): Uint8Array;
-function generateId(
-  type: "text" | "binary",
-  format: "v4" | "v7"
-): string | Uint8Array {
-  if (type === "text" && format === "v4") return uuidV4().text;
-  if (type === "binary" && format === "v4") return uuidV4().binary;
-  if (type === "text" && format === "v7") return uuidV7().text;
-  if (type === "binary" && format === "v7") return uuidV7().binary;
-  throw new Error("Invalid type or format");
-}
-
-export { generateId };

package/src/generators/generateSlug.ts

@@ -1,31 +0,0 @@
-/**
- * Generates a URL-friendly slug from a given string.
- *
- * The function performs the following transformations:
- * - Normalizes the string to remove diacritical marks (e.g., accents).
- * - Removes non-alphanumeric characters except for spaces and hyphens.
- * - Replaces spaces with hyphens.
- * - Converts the string to lowercase.
- * - Collapses multiple consecutive hyphens into a single hyphen.
- * - Trims leading and trailing hyphens.
- *
- * @param string - The input string to be converted into a slug.
- * @returns A URL-friendly slug derived from the input string.
- */
-
-function generateSlug(prop: string) {
-  let slug = prop.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-
-  slug = slug
-    .replace(/[^\w\s-]/g, "")
-    .replace(/\s+/g, "-")
-    .toLowerCase();
-
-  slug = slug.replace(/-{2,}/g, "-");
-
-  slug = slug.replace(/^-+|-+$/g, "");
-
-  return slug;
-}
-
-export { generateSlug };

package/src/index.ts

@@ -1,37 +0,0 @@
-// formats
-export { formatDate } from "./formats/formatDate";
-export { formatJsonObject } from "./formats/formatJsonObject";
-export { formatJsonString } from "./formats/formatJsonString";
-export { formatToCapitalizeFirstWordLetter } from "./formats/formatToCapitalizeFirstWordLetter";
-export { formatToCep } from "./formats/formatToCep";
-export { formatToCnpj } from "./formats/formatToCnpj";
-export { formatToCpf } from "./formats/formatToCpf";
-export { formatToCpfCnpj } from "./formats/formatToCpfCnpj";
-export { formatToCurrency } from "./formats/formatToCurrency";
-export { formatToDate } from "./formats/formatToDate";
-export { formatToEllipsis } from "./formats/formatToEllipsis";
-export { formatToHiddenDigits } from "./formats/formatToHiddenDigits";
-export { formatToPhone } from "./formats/formatToPhone";
-
-// generators
-export { generateColorByString } from "./generators/generateColorByString";
-export { generateId } from "./generators/generateId";
-export { generateSlug } from "./generators/generateSlug";
-
-// services
-export { calculateCardInstallment } from "./services/calculateCardInstallment";
-export { ensureQuotes } from "./services/ensureQuotes";
-export { maskSensitiveData } from "./services/maskSensitiveData";
-export { removeCurrencySymbols } from "./services/removeCurrencySymbols";
-export { removeNonNumeric } from "./services/removeNonNumeric";
-export { stripHtmlTags } from "./services/stripHtmlTags";
-export { truncateLargeFields } from "./services/truncateLargeFields";
-
-// utils
-export { validateCep } from "./validations/validateCep";
-export { validateCnpj } from "./validations/validateCnpj";
-export { validateCpf } from "./validations/validateCpf";
-export { validateDate } from "./validations/validateDate";
-export { validatePassword } from "./validations/validatePassword";
-export { validatePhone } from "./validations/validatePhone";
-export { validateRg } from "./validations/validateRg";

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 };