@arkyn/shared 3.0.1-beta.55 → 3.0.1-beta.56

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@arkyn/shared",
-  "version": "3.0.1-beta.55",
+  "version": "3.0.1-beta.56",
   "main": "./dist/index.js",
-  "module": "./src/index.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "types": "./dist/index.d.ts",
   "license": "Apache-2.0",

package/src/formats/formatDate.ts

@@ -1,92 +0,0 @@
-type InputFormatTypes = "brazilianDate" | "isoDate" | "timestamp";
-
-type FormatDateFunction = (
-  date: string[], // [date: string, time?: string]
-  inputFormat: InputFormatTypes,
-  outputFormat: string,
-  timezone?: number
-) => string;
-
-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 and time string based on the provided input and output formats.
- *
- * @param {[string, string]} dateTime - An array containing the date and optional time.
- *   - The first element is the date string.
- *   - The second element is the time string (default is "00:00:00").
- * @param {"brazilianDate" | "isoDate" | "timestamp"} inputFormat - The format of the input date.
- *   - "brazilianDate": Expects the date in "DD/MM/YYYY" format.
- *   - "isoDate": Expects the date in "YYYY-MM-DD" format.
- *   - "timestamp": Expects the date in "YYYY/MM/DD" format.
- * @param {string} outputFormat - The desired output format for the date.
- *   - Use placeholders like "YYYY", "MM", "DD", "hh", "mm", "ss" to define the format.
- * @param {number} [timezone=0] - The timezone offset in hours to apply to the date.
- *   - Defaults to 0 (UTC).
- * @returns {string} The formatted date string based on the output format.
- * @throws {Error} If the input format is invalid.
- * @throws {Error} If the date is invalid.
- *
- * @example
- * // Format a Brazilian date to ISO format
- * formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm:ss");
- * // Returns: "2023-12-25 15:30:00"
- *
- * @example
- * // Format an ISO date to a custom format with timezone adjustment
- * formatDate(["2023-12-25", "15:30:00"], "isoDate", "DD/MM/YYYY hh:mm:ss", -3);
- * // Returns: "25/12/2023 12:30:00"
- */
-
-const formatDate: FormatDateFunction = (
-  [date, time = "00:00:00"],
-  inputFormat,
-  outputFormat,
-  timezone = 0
-) => {
-  const dateParts = date.split(/[-/]/).map(Number);
-  const timeParts = time.split(".")[0].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,90 +0,0 @@
-type FormatJsonObjectFunction = (jsonString: any, identLevel: number) => string;
-
-/**
- * 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)) {
-      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 {
-      const keys = Object.keys(obj);
-      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 {
-      const parsedObj = JSON.parse(obj);
-      formattedString += formatJsonObject(parsedObj, indentLevel);
-    } catch {
-      formattedString += '"' + obj + '"';
-    }
-  } else {
-    formattedString += obj;
-  }
-
-  return formattedString;
-};
-
-export { formatJsonObject };

package/src/formats/formatJsonString.ts

@@ -1,50 +0,0 @@
-import { formatJsonObject } from "./formatJsonObject";
-
-type FormatJsonStringFunction = (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) {
-    throw new Error(`Invalid JSON string \n ${error}`);
-  }
-};
-
-export { formatJsonString };

package/src/formats/formatToCapitalizeFirstWordLetter.ts

@@ -1,46 +0,0 @@
-/**
- * Formats a sentence by capitalizing the first letter of each word.
- *
- * This function takes a string and capitalizes the first letter of each word
- * while the remaining letters are lowercase.
- * Words are separated by spaces.
- *
- * @param sentence - The sentence to be formatted.
- * @returns The sentence formatted with the first letter of each word capitalized.
- *
- * @example
- * ```typescript
- * // Basic example
- * formatToCapitalizeFirstWordLetter("hello world");
- * // Returns: "Hello World"
- *
- * // With capitalized text.
- * formatToCapitalizeFirstWordLetter("HELLO WORLD");
- * // Returns: "Hello World"
- *
- * // With mixed text.
- * formatToCapitalizeFirstWordLetter("hELLO WoRLd"); * // Returns: "Hello World"
- *
- * // With multiple words
- * formatToCapitalizeFirstWordLetter("javascript is an amazing language");
- * // Returns: "Javascript is an amazing language"
- *
- * // Empty string
- * formatToCapitalizeFirstWordLetter("");
- * // Returns: ""
- * ```
- */
-
-function formatToCapitalizeFirstWordLetter(sentence: string) {
-  const words = sentence.split(" ");
-
-  const capitalizedWords = words.map((word) => {
-    const firstLetter = word.charAt(0).toUpperCase();
-    const restOfWord = word.slice(1).toLowerCase();
-    return firstLetter + restOfWord;
-  });
-
-  return capitalizedWords.join(" ");
-}
-
-export { formatToCapitalizeFirstWordLetter };

package/src/formats/formatToCep.ts

@@ -1,39 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCepFunction = (value: string) => string;
-
-/**
- * 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]}`;
-  throw new Error("Invalid CEP format");
-};
-
-export { formatToCep };

package/src/formats/formatToCnpj.ts

@@ -1,40 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCnpjFunction = (value: string) => string;
-
-/**
- * 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

@@ -1,40 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCpfFunction = (value: string) => string;
-
-/**
- * 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,38 +0,0 @@
-import { formatToCnpj } from "./formatToCnpj";
-import { formatToCpf } from "./formatToCpf";
-
-type FormatToCpfCnpjFunction = (value: string) => string;
-
-/**
- * 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);
-  } else if (cleaned.length === 14) {
-    return formatToCnpj(cleaned);
-  }
-
-  throw new Error("Invalid CPF or CNPJ length");
-};
-
-export { formatToCpfCnpj };

package/src/formats/formatToCurrency.ts

@@ -1,63 +0,0 @@
-import { countryCurrencies } from "@arkyn/templates";
-import { removeCurrencySymbols } from "../services/removeCurrencySymbols";
-
-type Currencies = keyof typeof countryCurrencies;
-
-type Config = {
-  showPrefix?: boolean;
-};
-
-type FormatToCurrency = (
-  value: number,
-  currency: Currencies,
-  config?: Config
-) => string;
-
-/**
- * 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/formatToDate.ts

@@ -1,70 +0,0 @@
-type InputFormatTypes = "brazilianDate" | "timestamp" | "isoDate";
-
-type FormatToDateFunction = (
-  date: string[], // [date: string, time?: string]
-  inputFormat: InputFormatTypes,
-  timezone?: number
-) => Date;
-
-/**
- * Converts a date and time input into a JavaScript `Date` object, formatted according to the specified input format and timezone.
- *
- * @param param0 - A tuple containing the date string and an optional time string.
- *                 The date string format depends on the `inputFormat` parameter.
- *                 The time string defaults to "00:00:00" if not provided.
- * @param inputFormat - The format of the input date string.
- *                      Supported formats are:
- *                      - `"brazilianDate"`: Expects the date in `DD/MM/YYYY` format.
- *                      - `"isoDate"`: Expects the date in `YYYY-MM-DD` format.
- *                      - `"timestamp"`: Expects the date in `YYYY-MM-DD` format (similar to `isoDate`).
- * @param timezone - An optional timezone offset in hours. Defaults to `0` (UTC).
- *
- * @returns A `Date` object representing the parsed date and time, adjusted for the specified timezone.
- *
- * @throws {Error} If the `inputFormat` is invalid.
- * @throws {Error} If the provided date or time is invalid.
- *
- * @example
- * ```typescript
- * import { formatToDate } from "./formatToIsoDate";
- *
- * const date = formatToDate(["25/12/2023", "15:30:00"], "brazilianDate", -3);
- * console.log(date); // Outputs a Date object for "2023-12-25T18:30:00.000Z" (UTC)
- * ```
- */
-
-const formatToDate: FormatToDateFunction = (
-  [date, time = "00:00:00"],
-  inputFormat,
-  timezone = 0
-) => {
-  const dateParts = date.split(/[-/]/).map(Number);
-  const timeParts = time.split(".")[0].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 utcDate = new Date(
-    Date.UTC(year, month - 1, day, hours - timezone, minutes, seconds)
-  );
-
-  if (isNaN(utcDate.getTime())) throw new Error("Invalid date");
-
-  return utcDate;
-};
-
-export { formatToDate };

package/src/formats/formatToEllipsis.ts

@@ -1,25 +0,0 @@
-type FormatToEllipsisFunction = (value: string, maxLength: number) => string;
-
-/**
- * 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 };