@arkyn/shared 1.4.57 → 1.5.0

package/src/formats/formatJsonString.ts

@@ -1,49 +1,13 @@
-import type { FormatJsonStringFunction } from "@arkyn/types";
 import { formatJsonObject } from "./formatJsonObject";
 
-/**
- * Formats a JSON string into a more readable format.
- *
- * This function attempts to parse the provided JSON string into a JavaScript object,
- * and then formats it using the `formatJsonObject` function. If the input string
- * is not a valid JSON, it logs an error to the console and returns an empty string.
- *
- * @param jsonString - The JSON string to be formatted.
- * @returns A formatted JSON string, or an empty string if the input is invalid.
- *
- * @throws Will log an error to the console if the input is not a valid JSON string.
- *
- * @example
- * ```typescript
- * const jsonString = '{"name":"John","age":30,"hobbies":["reading","gaming"]}';
- * const formatted = formatJsonString(jsonString);
- * console.log(formatted);
- * // Output:
- * // {
- * //   "name": "John",
- * //   "age": 30,
- * //   "hobbies": [
- * //     "reading",
- * //     "gaming"
- * //   ]
- * // }
-
- * const invalidJsonString = '{"name":"John", "age":30,';
- * const formatted = formatJsonString(invalidJsonString);
- * console.log(formatted);
- * // Output:
- * // (Logs "Invalid JSON string: ..." to the console)
- * // ""
- * ```
- */
-
-const formatJsonString: FormatJsonStringFunction = (jsonString) => {
+function formatJsonString(jsonString: string): string {
   try {
     const jsonObject = JSON.parse(jsonString);
     return formatJsonObject(jsonObject, 0);
   } catch (error) {
-    throw new Error(`Invalid JSON string \n ${error}`);
+    console.error("Invalid JSON string:", error);
+    return "";
   }
-};
+}
 
 export { formatJsonString };

package/src/formats/formatToBRL.ts

@@ -0,0 +1,10 @@
+function formatToBRL(value: number, showPrefix = true) {
+  const format = new Intl.NumberFormat("pt-BR", {
+    style: "currency",
+    currency: "BRL",
+  }).format(value);
+
+  return showPrefix ? format : format.replace("R$", "").trim();
+}
+
+export { formatToBRL };

package/src/formats/formatToCNPJ.ts

@@ -0,0 +1,10 @@
+function formatToCNPJ(value: string): string {
+  const cleaned = value.replace(/\D/g, "");
+  const match = cleaned.match(/^(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/);
+  if (match) {
+    return `${match[1]}.${match[2]}.${match[3]}/${match[4]}-${match[5]}`;
+  }
+  return value;
+}
+
+export { formatToCNPJ };

package/src/formats/formatToCPF.ts

@@ -0,0 +1,10 @@
+function formatToCPF(value: string): string {
+  const cleaned = value.replace(/\D/g, "");
+  const match = cleaned.match(/^(\d{3})(\d{3})(\d{3})(\d{2})$/);
+  if (match) {
+    return `${match[1]}.${match[2]}.${match[3]}-${match[4]}`;
+  }
+  return value;
+}
+
+export { formatToCPF };

package/src/formats/formatToCep.ts

@@ -1,38 +1,10 @@
-import type { FormatToCepFunction } from "@arkyn/types";
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-/**
- * Formats a given string into a Brazilian postal code (CEP) format.
- *
- * The function removes all non-numeric characters from the input string
- * and attempts to format it as a CEP in the pattern `XXXXX-XXX`.
- * If the input does not match the expected format, an error is thrown.
- *
- * @param value - The input string to be formatted as a CEP.
- * @returns The formatted CEP string in the pattern `XXXXX-XXX`.
- * @throws {Error} If the input does not match the expected CEP format.
- *
- * @example
- * ```typescript
- * import { formatToCep } from "./formatToCep";
- *
- * const formattedCep = formatToCep("12345678");
- * console.log(formattedCep); // Output: "12345-678"
- *
- * try {
- *   formatToCep("1234");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CEP format"
- * }
- * ```
- */
-
-const formatToCep: FormatToCepFunction = (value) => {
-  const cleaned = removeNonNumeric(value);
+function formatToCep(value: string): string {
+  const cleaned = value.replace(/\D/g, "");
   const match = cleaned.match(/^(\d{5})(\d{3})$/);
-
-  if (match) return `${match[1]}-${match[2]}`;
-  throw new Error("Invalid CEP format");
-};
+  if (match) {
+    return `${match[1]}-${match[2]}`;
+  }
+  return value;
+}
 
 export { formatToCep };

package/src/formats/formatToCpfCnpj.ts

@@ -1,38 +1,14 @@
-import type { FormatToCpfCnpjFunction } from "@arkyn/types";
+import { formatToCNPJ } from "./formatToCNPJ";
+import { formatToCPF } from "./formatToCPF";
 
-import { formatToCnpj } from "./formatToCnpj";
-import { formatToCpf } from "./formatToCpf";
-
-/**
- * Formats a given string value into either a CPF or CNPJ format based on its length.
- *
- * - If the input contains 11 numeric characters, it is formatted as a CPF.
- * - If the input contains 14 numeric characters, it is formatted as a CNPJ.
- * - Throws an error if the input length is neither 11 nor 14 after removing non-numeric characters.
- *
- * @param value - The string value to be formatted. It may contain non-numeric characters, which will be removed.
- * @returns The formatted CPF or CNPJ string.
- * @throws {Error} If the input does not have a valid CPF or CNPJ length.
- *
- * @example
- * ```typescript
- * formatToCpfCnpj("123.456.789-09"); // Returns "123.456.789-09" (CPF format)
- * formatToCpfCnpj("12.345.678/0001-95"); // Returns "12.345.678/0001-95" (CNPJ format)
- * formatToCpfCnpj("12345678909"); // Returns "123.456.789-09" (CPF format)
- * formatToCpfCnpj("12345678000195"); // Returns "12.345.678/0001-95" (CNPJ format)
- * formatToCpfCnpj("123"); // Throws an error: "Invalid CPF or CNPJ length"
- * ```
- */
-
-const formatToCpfCnpj: FormatToCpfCnpjFunction = (value) => {
+function formatToCpfCnpj(value: string): string {
   const cleaned = value.replace(/\D/g, "");
   if (cleaned.length === 11) {
-    return formatToCpf(cleaned);
+    return formatToCPF(cleaned);
   } else if (cleaned.length === 14) {
-    return formatToCnpj(cleaned);
+    return formatToCNPJ(cleaned);
   }
-
-  throw new Error("Invalid CPF or CNPJ length");
-};
+  return value;
+}
 
 export { formatToCpfCnpj };

package/src/formats/formatToEllipsis.ts

@@ -1,25 +1,5 @@
-import type { FormatToEllipsisFunction } from "@arkyn/types";
-
-/**
- * Truncates a given text to a specified maximum length and appends an ellipsis ("...")
- * if the text exceeds the maximum length.
- *
- * @param text - The input string to be truncated.
- * @param maxLength - The maximum allowed length of the string before truncation.
- * @returns The truncated string with an ellipsis if the input exceeds the maximum length,
- *          or the original string if it does not.
- * @example
- * const result = formatToEllipsis("Hello, world!", 5);
- * console.log(result); // Output: "Hello..."
- */
-
-const formatToEllipsis: FormatToEllipsisFunction = (text, maxLength) => {
-  if (text.length > maxLength) {
-    let trimmedText = text.substring(0, maxLength).trimEnd();
-    trimmedText = trimmedText.replace(/[.,!?;:]$/, "");
-    return `${trimmedText}...`;
-  }
-  return text;
-};
+function formatToEllipsis(text: string, size = 40): string {
+  return text.length > size ? `${text.substring(0, size)}...` : text;
+}
 
 export { formatToEllipsis };

package/src/formats/formatToHiddenDigits.ts

@@ -1,80 +1,12 @@
-import type { FormatToHiddenDigitsFunction } from "@arkyn/types";
+import type { FormatToHiddenDigitsOptions } from "@arkyn/types";
 
-const DIGIT = /^\d$/;
+import { parseToCharacters } from "../parsers/parseToCharacters";
+import { normalizeRange, within } from "../services/range";
 
-type DigitCharacterNode = {
-  kind: "digit";
-  digit: number;
-  character: string;
-};
-
-type OtherCharacterNode = {
-  kind: "other";
-  character: string;
-};
-
-type RootCharacterNode = {
-  kind: "root";
-  digits: number;
-  children: (DigitCharacterNode | OtherCharacterNode)[];
-};
-
-const parseToCharacters = (value: string): RootCharacterNode => {
-  let digits = 0;
-
-  const children = value
-    .split("")
-    .map((character: string): DigitCharacterNode | OtherCharacterNode => {
-      if (DIGIT.test(character))
-        return { character, kind: "digit", digit: ++digits };
-      return { character, kind: "other" };
-    });
-
-  return { digits, children, kind: "root" };
-};
-
-const normalizeRange = (
-  range: number | [number, number],
-  limit: number
-): [number, number] => {
-  if (Array.isArray(range)) return range;
-  if (range >= 0) return [0, range];
-  return [limit + 1 - Math.abs(range), limit];
-};
-
-const within = (range: [number, number], value: number): boolean =>
-  value >= range[0] && value <= range[1];
-
-/**
- * Formats a string by hiding specific digits within a given range.
- *
- * This function takes a string input and replaces digits within a specified range
- * with a hiding character (e.g., "*"). Non-digit characters remain unchanged.
- *
- * @param value - The input string to be formatted.
- * @param options - Configuration options for formatting.
- * @param options.range - The range of digits to hide. It can be:
- *   - A single number (e.g., `3`), which hides the first `n` digits if positive,
- *     or the last `n` digits if negative.
- *   - A tuple `[start, end]` specifying the range of digits to hide (inclusive).
- *   - Defaults to `3`, hiding the first three digits.
- * @param options.hider - The character used to hide digits. Defaults to `"*"`.
- *
- * @returns The formatted string with specified digits hidden.
- *
- * @example
- * ```typescript
- * import { formatToHiddenDigits } from "./formatToHiddenDigits";
- *
- * formatToHiddenDigits("123-456-7890", { range: 3 });
- * // Output: "***-456-7890"
- *
- * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
- * // Output: "123-###-7890"
- * ```
- */
-
-const formatToHiddenDigits: FormatToHiddenDigitsFunction = (value, options) => {
+const formatToHiddenDigits = (
+  value: string,
+  options: FormatToHiddenDigitsOptions = {}
+): string => {
   const characters = parseToCharacters(value);
   const range = normalizeRange(options.range ?? 3, characters.digits);
   return characters.children

package/src/formats/formatToPhone.ts

@@ -1,160 +1,10 @@
-import { countries } from "@arkyn/templates";
-import type { CountryType, FormatToPhoneFunction } from "@arkyn/types";
-
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-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");
+function formatToPhone(value: string): string {
+  const cleaned = value.replace(/\D/g, "");
+  const match = cleaned.match(/^(\d{2})(\d{5})(\d{4})$/);
+  if (match) {
+    return `(${match[1]}) ${match[2]}-${match[3]}`;
   }
-
-  if (!country.prefix) {
-    throw new Error("Invalid country code or prefix");
-  }
-  return country;
+  return value;
 }
 
-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-11 912345678"
- *               - "+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,22 +1,8 @@
-import type { GenerateColorByStringFunction } from "@arkyn/types";
-
-/**
- * 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) => {
+function generateColorByString(string: string) {
   var hash = 0;
 
-  for (var i = 0; i < prop.length; i++) {
-    hash = prop.charCodeAt(i) + ((hash << 5) - hash);
+  for (var i = 0; i < string.length; i++) {
+    hash = string.charCodeAt(i) + ((hash << 5) - hash);
   }
 
   var red = (hash & 0xff0000) >> 16;
@@ -28,6 +14,6 @@ const generateColorByString: GenerateColorByStringFunction = (prop) => {
   var blueHex = blue.toString(16).padStart(2, "0");
 
   return "#" + redHex + greenHex + blueHex;
-};
+}
 
 export { generateColorByString };

package/src/generators/generateId.ts

@@ -1,7 +1,6 @@
 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) {
@@ -21,41 +20,11 @@ function uuidV7() {
   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");
+function generateId(type: "text" | "binary") {
+  return {
+    v4: uuidV4()[type],
+    v7: uuidV7()[type],
+  };
 }
 
 export { generateId };

package/src/generators/generateSlug.ts

@@ -1,20 +1,5 @@
-/**
- * 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, "");
+function generateSlug(string: string) {
+  let slug = string.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
 
   slug = slug
     .replace(/[^\w\s-]/g, "")

package/src/index.ts

@@ -1,26 +1,34 @@
-export { formatDate } from "./formats/formatDate";
+// formats
+export { formatBrazilianDateHour } from "./formats/formatBrazilianDateHour";
+export { formatBrazilianDateToDate } from "./formats/formatBrazilianDateToDate";
+export { formatDateHour } from "./formats/formatDateHour";
 export { formatJsonObject } from "./formats/formatJsonObject";
 export { formatJsonString } from "./formats/formatJsonString";
+export { formatToBRL } from "./formats/formatToBRL";
 export { formatToCep } from "./formats/formatToCep";
-export { formatToCnpj } from "./formats/formatToCnpj";
-export { formatToCpf } from "./formats/formatToCpf";
+export { formatToCNPJ } from "./formats/formatToCNPJ";
+export { formatToCPF } from "./formats/formatToCPF";
 export { formatToCpfCnpj } from "./formats/formatToCpfCnpj";
-export { formatToCurrency } from "./formats/formatToCurrency";
 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";
 
-export { regex } from "./regex";
+// parsers
+export { parseToCharacters } from "./parsers/parseToCharacters";
 
+// services
 export { calculateCardInstallment } from "./services/calculateCardInstallment";
 export { maskSensitiveData } from "./services/maskSensitiveData";
-export { removeNonNumeric } from "./services/removeNonNumeric";
+export { normalizeRange, within } from "./services/range";
 export { truncateLargeFields } from "./services/truncateLargeFields";
 
-export { validateCpf } from "./validations/validateCpf";
+// validations
+export { regex } from "./validations/regex";
+export { validateCPF } from "./validations/validateCPF";
 export { validateDate } from "./validations/validateDate";
 export { validatePhone } from "./validations/validatePhone";

package/src/parsers/parseToCharacters.ts

@@ -0,0 +1,34 @@
+const DIGIT = /^\d$/;
+
+type DigitCharacterNode = {
+  kind: "digit";
+  digit: number;
+  character: string;
+};
+
+type OtherCharacterNode = {
+  kind: "other";
+  character: string;
+};
+
+type RootCharacterNode = {
+  kind: "root";
+  digits: number;
+  children: (DigitCharacterNode | OtherCharacterNode)[];
+};
+
+const parseToCharacters = (value: string): RootCharacterNode => {
+  let digits = 0;
+
+  const children = value
+    .split("")
+    .map((character: string): DigitCharacterNode | OtherCharacterNode => {
+      if (DIGIT.test(character))
+        return { character, kind: "digit", digit: ++digits };
+      return { character, kind: "other" };
+    });
+
+  return { digits, children, kind: "root" };
+};
+
+export { parseToCharacters };