@arkyn/shared 1.4.52 → 1.4.55

package/dist/validations/validatePhone.d.ts

@@ -1,3 +1,29 @@
-declare function validatePhone(phone: string): boolean;
+import type { ValidatePhoneFunction } from "@arkyn/types";
+/**
+ * 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 phone - 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
+ * ```
+ */
+declare const validatePhone: ValidatePhoneFunction;
 export { validatePhone };
 //# sourceMappingURL=validatePhone.d.ts.map

package/dist/validations/validatePhone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAiB7C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -1,5 +1,30 @@
 import { countries } from "@arkyn/templates";
-function validatePhone(phone) {
+/**
+ * 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 phone - 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 = (phone) => {
     for (const country of countries) {
         const countryCode = country.code;
         const prefix = country.prefix ? `-${country.prefix}` : "";
@@ -15,5 +40,5 @@ function validatePhone(phone) {
             return true;
     }
     return false;
-}
+};
 export { validatePhone };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkyn/shared",
-  "version": "1.4.52",
+  "version": "1.4.55",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
@@ -8,10 +8,12 @@
   "scripts": {
     "clean": "rm -rf dist",
     "build": "bun run clean && bunx tsc --project tsconfig.json",
+    "test": "vitest --config ./vitest.config.ts",
     "typecheck": "bunx tsc --project tsconfig.json --noEmit"
   },
   "dependencies": {
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "vitest": "^3.1.1"
   },
   "devDependencies": {
     "@types/uuid": "^10.0.0",

package/src/formats/formatDate.ts

@@ -0,0 +1,97 @@
+import type { FormatDateFunction } from "@arkyn/types";
+
+function formatDateString(date: Date, format: string): string {
+  const pad = (num: number) => num.toString().padStart(2, "0");
+
+  const replacements: Record<string, string> = {
+    YYYY: date.getFullYear().toString(),
+    YY: date.getFullYear().toString().slice(-2),
+    MM: pad(date.getMonth() + 1),
+    DD: pad(date.getDate()),
+    hh: pad(date.getHours()),
+    mm: pad(date.getMinutes()),
+    ss: pad(date.getSeconds()),
+  };
+
+  return format.replace(
+    /YYYY|YY|MM|DD|hh|mm|ss/g,
+    (match) => replacements[match]
+  );
+}
+
+/**
+ * Formats a date string from a given input format to a specified output format,
+ * with optional timezone adjustment.
+ *
+ * @param date - The date string to be formatted. It should match the specified `inputFormat`.
+ * @param time - The time string in the format `hh:mm:ss` (e.g., `14:30:00`).
+ * @param inputFormat - The format of the input date string. Supported formats:
+ *   - `"brazilianDate"`: Expects the date in `DD/MM/YYYY` format.
+ *   - `"isoDate"`: Expects the date in `YYYY-MM-DD` format.
+ *   - `"timestamp"`: Expects the date as a numeric timestamp (e.g., `YYYY-MM-DD`).
+ *
+ * @param outputFormat - The desired format for the output date string. Supported tokens:
+ *   - `YYYY`: Full year (e.g., 2023)
+ *   - `YY`: Last two digits of the year (e.g., 23)
+ *   - `MM`: Month (zero-padded, e.g., 01)
+ *   - `DD`: Day of the month (zero-padded, e.g., 09)
+ *   - `hh`: Hours (zero-padded, 24-hour format, e.g., 08)
+ *   - `mm`: Minutes (zero-padded, e.g., 05)
+ *   - `ss`: Seconds (zero-padded, e.g., 07)
+ * @param timezone - (Optional) The timezone offset in hours to adjust the date. Defaults to `0`.
+ *
+ * @returns The formatted date string in the specified `outputFormat`.
+ *
+ * @throws Will throw an error if:
+ *   - The `inputFormat` is invalid.
+ *   - The `date` string does not match the expected `inputFormat`.
+ *   - The `time` string is not in the format `hh:mm:ss`.
+ *   - The resulting date is invalid.
+ *
+ * @example
+ * ```typescript
+ * import { formatDate } from "./formatDate";
+ *
+ * const date = "25/12/2023";
+ * const time = "14:30:00";
+ * const formatted = formatDate(date, time, "brazilianDate", "YYYY-MM-DD hh:mm:ss", -3);
+ * console.log(formatted); // Outputs: "2023-12-25 14:30:00"
+ * ```
+ */
+
+const formatDate: FormatDateFunction = (
+  date,
+  time,
+  inputFormat,
+  outputFormat,
+  timezone = 0
+) => {
+  const dateParts = date.split(/[-/]/).map(Number);
+  const timeParts = time.split(":").map(Number);
+
+  let day, month, year;
+  const [hours = 0, minutes = 0, seconds = 0] = timeParts;
+
+  switch (inputFormat) {
+    case "brazilianDate":
+      [day, month, year] = dateParts;
+      break;
+    case "isoDate":
+      [year, month, day] = dateParts;
+      break;
+    case "timestamp":
+      [year, month, day] = dateParts.map(Number);
+      break;
+    default:
+      throw new Error("Invalid input format");
+  }
+
+  const formattedDate = new Date(year, month - 1, day, hours, minutes, seconds);
+  if (isNaN(formattedDate.getTime())) throw new Error("Invalid date");
+
+  formattedDate.setUTCHours(formattedDate.getUTCHours() + timezone);
+
+  return formatDateString(formattedDate, outputFormat);
+};
+
+export { formatDate };

package/src/formats/formatJsonObject.ts

@@ -1,35 +1,77 @@
-function formatJsonObject(obj: any, indentLevel: number): string {
+import type { FormatJsonObjectFunction } from "@arkyn/types";
+
+/**
+ * Formats a JSON object into a human-readable string with proper indentation.
+ *
+ * @param obj - The JSON object or value to format. It can be an object, array, string, or primitive value.
+ * @param indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
+ * @returns A formatted string representation of the JSON object.
+ *
+ * @remarks
+ * - If the input is an object, it will be formatted with keys and values properly indented.
+ * - If the input is an array, each element will be formatted and indented on a new line.
+ * - If the input is a string that can be parsed as JSON, it will attempt to parse and format it.
+ * - Primitive values (e.g., numbers, booleans, null) will be converted to their string representation.
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
+ * const formatted = formatJsonObject(obj, 0);
+ * console.log(formatted);
+ * // Output:
+ * // {
+ * //   "name": "John",
+ * //   "age": 30,
+ * //   "hobbies": [
+ * //     "reading",
+ * //     "gaming"
+ * //   ]
+ * // }
+ * ```
+ */
+
+const formatJsonObject: FormatJsonObjectFunction = (obj, indentLevel) => {
   const indent = "  ".repeat(indentLevel);
   let formattedString = "";
 
   if (typeof obj === "object" && obj !== null) {
     if (Array.isArray(obj)) {
-      formattedString += "[\n";
-      obj.forEach((item, index) => {
-        formattedString +=
-          indent + "  " + formatJsonObject(item, indentLevel + 1);
-        if (index < obj.length - 1) {
-          formattedString += ",";
-        }
-        formattedString += "\n";
-      });
-      formattedString += indent + "]";
+      if (obj.length === 0) {
+        // Caso especial para arrays vazios
+        formattedString += "[]";
+      } else {
+        formattedString += "[\n";
+        obj.forEach((item, index) => {
+          formattedString +=
+            indent + "  " + formatJsonObject(item, indentLevel + 1);
+          if (index < obj.length - 1) {
+            formattedString += ",";
+          }
+          formattedString += "\n";
+        });
+        formattedString += indent + "]";
+      }
     } else {
-      formattedString += "{\n";
       const keys = Object.keys(obj);
-      keys.forEach((key, index) => {
-        formattedString +=
-          indent +
-          '  "' +
-          key +
-          '": ' +
-          formatJsonObject(obj[key], indentLevel + 1);
-        if (index < keys.length - 1) {
-          formattedString += ",";
-        }
-        formattedString += "\n";
-      });
-      formattedString += indent + "}";
+      if (keys.length === 0) {
+        // Caso especial para objetos vazios
+        formattedString += "{}";
+      } else {
+        formattedString += "{\n";
+        keys.forEach((key, index) => {
+          formattedString +=
+            indent +
+            '  "' +
+            key +
+            '": ' +
+            formatJsonObject(obj[key], indentLevel + 1);
+          if (index < keys.length - 1) {
+            formattedString += ",";
+          }
+          formattedString += "\n";
+        });
+        formattedString += indent + "}";
+      }
     }
   } else if (typeof obj === "string") {
     try {
@@ -43,6 +85,6 @@ function formatJsonObject(obj: any, indentLevel: number): string {
   }
 
   return formattedString;
-}
+};
 
 export { formatJsonObject };

package/src/formats/formatJsonString.ts

@@ -1,13 +1,49 @@
+import type { FormatJsonStringFunction } from "@arkyn/types";
 import { formatJsonObject } from "./formatJsonObject";
 
-function formatJsonString(jsonString: string): string {
+/**
+ * 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) => {
   try {
     const jsonObject = JSON.parse(jsonString);
     return formatJsonObject(jsonObject, 0);
   } catch (error) {
-    console.error("Invalid JSON string:", error);
-    return "";
+    throw new Error(`Invalid JSON string \n ${error}`);
   }
-}
+};
 
 export { formatJsonString };

package/src/formats/formatToCep.ts

@@ -1,10 +1,38 @@
-function formatToCep(value: string): string {
-  const cleaned = value.replace(/\D/g, "");
+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);
   const match = cleaned.match(/^(\d{5})(\d{3})$/);
-  if (match) {
-    return `${match[1]}-${match[2]}`;
-  }
-  return value;
-}
+
+  if (match) return `${match[1]}-${match[2]}`;
+  throw new Error("Invalid CEP format");
+};
 
 export { formatToCep };

package/src/formats/formatToCnpj.ts

@@ -0,0 +1,39 @@
+import type { FormatToCnpjFunction } from "@arkyn/types";
+import { removeNonNumeric } from "../services/removeNonNumeric";
+
+/**
+ * Formats a given string or number into a CNPJ (Cadastro Nacional da Pessoa Jurídica) format.
+ *
+ * The CNPJ format is: `XX.XXX.XXX/XXXX-XX`, where `X` represents a digit.
+ *
+ * @param value - The input value to be formatted. It can be a string or number containing the CNPJ digits.
+ *                Non-numeric characters will be removed before formatting.
+ *
+ * @returns A string formatted as a CNPJ.
+ *
+ * @throws {Error} Throws an error if the input does not contain exactly 14 numeric digits.
+ *
+ * @example
+ * ```typescript
+ * import { formatToCnpj } from "./formatToCNPJ";
+ *
+ * const formattedCnpj = formatToCnpj("12345678000195");
+ * console.log(formattedCnpj); // Output: "12.345.678/0001-95"
+ *
+ * try {
+ *   formatToCnpj("12345");
+ * } catch (error) {
+ *   console.error(error.message); // Output: "Invalid CNPJ length"
+ * }
+ * ```
+ */
+
+const formatToCnpj: FormatToCnpjFunction = (value) => {
+  const cleaned = removeNonNumeric(value);
+  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]}`;
+  throw new Error("Invalid CNPJ length");
+};
+
+export { formatToCnpj };

package/src/formats/formatToCpf.ts

@@ -0,0 +1,39 @@
+import type { FormatToCpfFunction } from "@arkyn/types";
+import { removeNonNumeric } from "../services/removeNonNumeric";
+
+/**
+ * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
+ * 
+ * A CPF is a Brazilian individual taxpayer registry identification format.
+ * This function ensures the input is cleaned of non-numeric characters and
+ * then formats it into the standard CPF format: `XXX.XXX.XXX-XX`.
+ *
+ * @param value - The input string to be formatted as a CPF.
+ * @returns The formatted CPF string.
+ * @throws {Error} If the input string does not match the expected CPF format.
+ *
+ * @example
+ * ```typescript
+ * import { formatToCpf } from "./formatToCPF";
+ *
+ * const formattedCpf = formatToCpf("12345678909");
+ * console.log(formattedCpf); // Output: "123.456.789-09"
+
+ * try {
+ *   const formattedCpf = formatToCpf("12345");
+ * } catch (error) {
+ *   console.error(error.message); // Output: "Invalid CPF format"
+ * }
+ * 
+ * ```
+ */
+
+const formatToCpf: FormatToCpfFunction = (value) => {
+  const cleaned = removeNonNumeric(value);
+  const match = cleaned.match(/^(\d{3})(\d{3})(\d{3})(\d{2})$/);
+
+  if (match) return `${match[1]}.${match[2]}.${match[3]}-${match[4]}`;
+  throw new Error("Invalid CPF format");
+};
+
+export { formatToCpf };

package/src/formats/formatToCpfCnpj.ts

@@ -1,14 +1,38 @@
-import { formatToCNPJ } from "./formatToCNPJ";
-import { formatToCPF } from "./formatToCPF";
+import type { FormatToCpfCnpjFunction } from "@arkyn/types";
 
-function formatToCpfCnpj(value: string): string {
+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) => {
   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);
   }
-  return value;
-}
+
+  throw new Error("Invalid CPF or CNPJ length");
+};
 
 export { formatToCpfCnpj };

package/src/formats/formatToCurrency.ts

@@ -0,0 +1,53 @@
+import { countryCurrencies } from "@arkyn/templates";
+import type { FormatToCurrency } from "@arkyn/types";
+
+import { removeCurrencySymbols } from "../services/removeCurrencySymbols";
+
+/**
+ * Formats a numeric value into a currency string based on the specified currency and configuration.
+ *
+ * @param value - The numeric value to be formatted.
+ * @param currency - The currency code used to determine the formatting style.
+ * @param config - Optional configuration object.
+ * @param config.showPrefix - Determines whether the currency symbol/prefix should be included in the formatted string. Defaults to `true`.
+ *
+ * @returns A formatted currency string. If `config.showPrefix` is `false`, the currency symbol is removed.
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatToCurrency(1234.56, "USD", { showPrefix: true });
+ * console.log(formatted); // "$1,234.56"
+ *
+ * const withoutPrefix = formatToCurrency(1234.56, "USD", { showPrefix: false });
+ * console.log(withoutPrefix); // "1,234.56"
+ *
+ * const formattedBRL = formatToCurrency(1234.56, "BRL", { showPrefix: true });
+ * console.log(formattedBRL); // "R$ 1.234,56"
+ *
+ * const withoutPrefixBRL = formatToCurrency(1234.56, "BRL", { showPrefix: false });
+ * console.log(withoutPrefixBRL); // "1.234,56"
+ * ```
+ */
+
+const formatToCurrency: FormatToCurrency = (
+  value,
+  currency,
+  config = { showPrefix: true }
+) => {
+  if (!countryCurrencies[currency]) {
+    throw new Error("Unsupported currency code");
+  }
+
+  const { countryCurrency, countryLanguage } = countryCurrencies[currency];
+
+  const format = new Intl.NumberFormat(countryLanguage, {
+    style: "currency",
+    currency: countryCurrency,
+  }).format(value);
+
+  return config.showPrefix
+    ? format.replace(/\s/g, " ")
+    : removeCurrencySymbols(format).replace(/\s/g, " ");
+};
+
+export { formatToCurrency };

package/src/formats/formatToEllipsis.ts

@@ -1,5 +1,25 @@
-function formatToEllipsis(text: string, size = 40): string {
-  return text.length > size ? `${text.substring(0, size)}...` : text;
-}
+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;
+};
 
 export { formatToEllipsis };