@arkyn/shared 3.0.1-beta.13 → 3.0.1-beta.130

package/dist/formats/formatDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatDate.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;AAElE,KAAK,kBAAkB,GAAG,CACxB,IAAI,EAAE,MAAM,EAAE,EAAE,gCAAgC;AAChD,WAAW,EAAE,gBAAgB,EAC7B,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC;AAqBZ;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAgCjB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatDate.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,iBAAS,UAAU,CACjB,CAAC,IAAI,EAAE,IAAiB,CAAC,EAAE,MAAM,EAAE,EACnC,WAAW,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,EACtD,YAAY,EAAE,MAAM,EACpB,QAAQ,GAAE,MAAU,GACnB,MAAM,CAkCR;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/formats/formatDate.js

@@ -1,45 +1,79 @@
+import { ValidateDateService } from "../services/validateDateService";
 function formatDateString(date, format) {
     const pad = (num) => num.toString().padStart(2, "0");
     const replacements = {
-        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()),
+        YYYY: date.getUTCFullYear().toString(),
+        YY: date.getUTCFullYear().toString().slice(-2),
+        MM: pad(date.getUTCMonth() + 1),
+        DD: pad(date.getUTCDate()),
+        hh: pad(date.getUTCHours()),
+        mm: pad(date.getUTCMinutes()),
+        ss: pad(date.getUTCSeconds()),
     };
     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.
+ * @remarks
+ * **Note:** This function works with UTC+0 by default. The returned formatted string is not automatically converted to the machine's local timezone.
+ * To adjust the timezone, you must manually specify the `timezone` parameter (e.g., -3 for UTC-3).
+ *
+ * @param {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.
+ *   - "brazilianDate": Expects the date in "DD/MM/YYYY" or "D/M/YYYY" format.
+ *   - "isoDate": Expects the date in "MM-DD-YYYY" or "M-D-YYYY" format.
+ *   - "timestamp": Expects the date in "YYYY-MM-DD" or "YYYY-M-D" 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.
  *
+ * @throws {Error} If the date parts are invalid (e.g., month not between 1-12).
+ * @throws {Error} If the date created is invalid.
+ *
+ * @example
+ * Format a Brazilian date to ISO format
+ * ```typescript
+ * const formattedDate = formatDate(
+ *   ["25/12/2023", "15:30:00"],
+ *   "brazilianDate",
+ *   "YYYY-MM-DD hh:mm",
+ * );
+ *
+ * console.log(formattedDate); // Output: "2023-12-25 15:30"
+ * ```
  * @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"
+ * Format an ISO date to a custom format with timezone adjustment
+ * ```typescript
+ * const formattedDate = formatDate(
+ *   ["2023-12-25", "15:30:00"],
+ *   "isoDate",
+ *   "DD/MM/YYYY hh:mm",
+ *   -3,
+ * );
  *
+ * console.log(formattedDate); // Output: "25/12/2023 12:30"
+ * ```
  * @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"
+ * Format a timestamp date to a custom format
+ * ```typescript
+ * const formattedDate = formatDate(
+ *   ["2023-12-25", "15:30:00"],
+ *   "timestamp",
+ *   "MM-DD-YYYY hh:mm:ss",
+ * );
+ *
+ * console.log(formattedDate); // Output: "12-25-2023 15:30:00"
+ * ```
  */
-const formatDate = ([date, time = "00:00:00"], inputFormat, outputFormat, timezone = 0) => {
+function formatDate([date, time = "00:00:00"], inputFormat, outputFormat, timezone = 0) {
+    const validateDateService = new ValidateDateService();
+    validateDateService.validateInputFormat(inputFormat);
     const dateParts = date.split(/[-/]/).map(Number);
     const timeParts = time.split(".")[0].split(":").map(Number);
     let day, month, year;
@@ -47,20 +81,21 @@ const formatDate = ([date, time = "00:00:00"], inputFormat, outputFormat, timezo
     switch (inputFormat) {
         case "brazilianDate":
             [day, month, year] = dateParts;
+            validateDateService.validateDateParts(year, month, day);
             break;
         case "isoDate":
-            [year, month, day] = dateParts;
+            [month, day, year] = dateParts;
+            validateDateService.validateDateParts(year, month, day);
             break;
         case "timestamp":
-            [year, month, day] = dateParts.map(Number);
+            [year, month, day] = dateParts;
+            validateDateService.validateDateParts(year, month, day);
             break;
-        default:
-            throw new Error("Invalid input format");
     }
-    const formattedDate = new Date(year, month - 1, day, hours, minutes, seconds);
+    const formattedDate = new Date(Date.UTC(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/dist/formats/formatJsonObject.d.ts

@@ -1,17 +1,16 @@
-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.
  *
+ * @param {any} json - The JSON object or value to format. It can be an object, array, string, or primitive value.
+ * @param {number} indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
+ *
+ * @returns {string} A formatted string representation of the JSON object.
+ *
  * @example
  * ```typescript
  * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
@@ -28,6 +27,6 @@ type FormatJsonObjectFunction = (jsonString: any, identLevel: number) => string;
  * // }
  * ```
  */
-declare const formatJsonObject: FormatJsonObjectFunction;
+declare const formatJsonObject: (json: any, indentLevel: number) => string;
 export { formatJsonObject };
 //# sourceMappingURL=formatJsonObject.d.ts.map

package/dist/formats/formatJsonObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatJsonObject.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonObject.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,CAAC,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAuDvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatJsonObject.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,QAAA,MAAM,gBAAgB,GAAI,MAAM,GAAG,EAAE,aAAa,MAAM,KAAG,MAuD1D,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonObject.js

@@ -1,16 +1,16 @@
 /**
  * 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.
  *
+ * @param {any} json - The JSON object or value to format. It can be an object, array, string, or primitive value.
+ * @param {number} indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
+ *
+ * @returns {string} A formatted string representation of the JSON object.
+ *
  * @example
  * ```typescript
  * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
@@ -27,21 +27,21 @@
  * // }
  * ```
  */
-const formatJsonObject = (obj, indentLevel) => {
+const formatJsonObject = (json, indentLevel) => {
     const indent = "  ".repeat(indentLevel);
     let formattedString = "";
-    if (typeof obj === "object" && obj !== null) {
-        if (Array.isArray(obj)) {
-            if (obj.length === 0) {
+    if (typeof json === "object" && json !== null) {
+        if (Array.isArray(json)) {
+            if (json.length === 0) {
                 // Caso especial para arrays vazios
                 formattedString += "[]";
             }
             else {
                 formattedString += "[\n";
-                obj.forEach((item, index) => {
+                json.forEach((item, index) => {
                     formattedString +=
                         indent + "  " + formatJsonObject(item, indentLevel + 1);
-                    if (index < obj.length - 1) {
+                    if (index < json.length - 1) {
                         formattedString += ",";
                     }
                     formattedString += "\n";
@@ -50,7 +50,7 @@ const formatJsonObject = (obj, indentLevel) => {
             }
         }
         else {
-            const keys = Object.keys(obj);
+            const keys = Object.keys(json);
             if (keys.length === 0) {
                 // Caso especial para objetos vazios
                 formattedString += "{}";
@@ -63,7 +63,7 @@ const formatJsonObject = (obj, indentLevel) => {
                             '  "' +
                             key +
                             '": ' +
-                            formatJsonObject(obj[key], indentLevel + 1);
+                            formatJsonObject(json[key], indentLevel + 1);
                     if (index < keys.length - 1) {
                         formattedString += ",";
                     }
@@ -73,17 +73,17 @@ const formatJsonObject = (obj, indentLevel) => {
             }
         }
     }
-    else if (typeof obj === "string") {
+    else if (typeof json === "string") {
         try {
-            const parsedObj = JSON.parse(obj);
+            const parsedObj = JSON.parse(json);
             formattedString += formatJsonObject(parsedObj, indentLevel);
         }
         catch {
-            formattedString += '"' + obj + '"';
+            formattedString += '"' + json + '"';
         }
     }
     else {
-        formattedString += obj;
+        formattedString += json;
     }
     return formattedString;
 };

package/dist/formats/formatToCep.d.ts

@@ -1,4 +1,3 @@
-type FormatToCepFunction = (value: string) => string;
 /**
  * Formats a given string into a Brazilian postal code (CEP) format.
  *
@@ -6,24 +5,18 @@ type FormatToCepFunction = (value: string) => 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`.
+ * @param {string} value - The input string to be formatted as a CEP, the string must contain 8 numeric digits; special characters will be ignored.
+ *
+ * @returns {string} 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"
- * }
  * ```
  */
-declare const formatToCep: FormatToCepFunction;
+declare function formatToCep(value: string): string;
 export { formatToCep };
 //# sourceMappingURL=formatToCep.d.ts.map

package/dist/formats/formatToCep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToCep.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCep.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"formatToCep.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCep.js

@@ -1,4 +1,4 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
+import { removeNonNumeric } from "../utilities/removeNonNumeric";
 /**
  * Formats a given string into a Brazilian postal code (CEP) format.
  *
@@ -6,29 +6,24 @@ import { removeNonNumeric } from "../services/removeNonNumeric";
  * 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`.
+ * @param {string} value - The input string to be formatted as a CEP, the string must contain 8 numeric digits; special characters will be ignored.
+ *
+ * @returns {string} 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 = (value) => {
+function formatToCep(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");
-};
+    const errorMessage = `CEP must be contain 8 numeric digits: ${value}`;
+    if (!match)
+        throw new Error(errorMessage);
+    return `${match[1]}-${match[2]}`;
+}
 export { formatToCep };

package/dist/formats/formatToCnpj.d.ts

@@ -1,30 +1,20 @@
-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.
+ * @param {string} value - The input string to be formatted as a CNPJ, the string must contain 14 numeric digits; special characters will be ignored.
  *
- * @returns A string formatted as a CNPJ.
+ * @returns {string} The formatted CNPJ string in the pattern `XX.XXX.XXX/XXXX-XX`.
  *
  * @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"
- * }
  * ```
  */
-declare const formatToCnpj: FormatToCnpjFunction;
+declare function formatToCnpj(value: string): string;
 export { formatToCnpj };
 //# sourceMappingURL=formatToCnpj.d.ts.map

package/dist/formats/formatToCnpj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCnpj.ts"],"names":[],"mappings":"AAEA,KAAK,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAMnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"formatToCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCnpj.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,iBAAS,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/formats/formatToCnpj.js

@@ -1,35 +1,27 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
+import { removeNonNumeric } from "../utilities/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.
+ * @param {string} value - The input string to be formatted as a CNPJ, the string must contain 14 numeric digits; special characters will be ignored.
  *
- * @returns A string formatted as a CNPJ.
+ * @returns {string} The formatted CNPJ string in the pattern `XX.XXX.XXX/XXXX-XX`.
  *
  * @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 = (value) => {
+function formatToCnpj(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");
-};
+    const errorMessage = `CNPJ must be contain 14 numeric digits: ${value}`;
+    if (!match)
+        throw new Error(errorMessage);
+    return `${match[1]}.${match[2]}.${match[3]}/${match[4]}-${match[5]}`;
+}
 export { formatToCnpj };

package/dist/formats/formatToCpf.d.ts

@@ -1,4 +1,3 @@
-type FormatToCpfFunction = (value: string) => string;
 /**
  * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
  *
@@ -6,25 +5,18 @@ type FormatToCpfFunction = (value: string) => string;
  * 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.
+ * @param {string} value -  The input string to be formatted as a CPF, the string must contain 11 numeric digits; special characters will be ignored.
+ *
+ * @returns {string} 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"
- * }
- *
  * ```
  */
-declare const formatToCpf: FormatToCpfFunction;
+declare function formatToCpf(value: string): string;
 export { formatToCpf };
 //# sourceMappingURL=formatToCpf.d.ts.map

package/dist/formats/formatToCpf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToCpf.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpf.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"formatToCpf.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpf.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCpf.js

@@ -1,4 +1,4 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
+import { removeNonNumeric } from "../utilities/removeNonNumeric";
 /**
  * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
  *
@@ -6,30 +6,24 @@ import { removeNonNumeric } from "../services/removeNonNumeric";
  * 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.
+ * @param {string} value -  The input string to be formatted as a CPF, the string must contain 11 numeric digits; special characters will be ignored.
+ *
+ * @returns {string} 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 = (value) => {
+function formatToCpf(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");
-};
+    const errorMessage = `CPF must be contain 11 numeric digits: ${value}`;
+    if (!match)
+        throw new Error(errorMessage);
+    return `${match[1]}.${match[2]}.${match[3]}-${match[4]}`;
+}
 export { formatToCpf };

package/dist/formats/formatToCurrency.d.ts

@@ -1,34 +1,38 @@
 import { countryCurrencies } from "@arkyn/templates";
 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`.
+ * @param {number} value - The numeric value to be formatted.
+ * @param {Currencies} currency - The currency code used to determine the formatting style.
+ * @param {object} [config] - Optional configuration object.
+ * @param {boolean} [config.showPrefix=true] - 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.
+ * @returns {string} A formatted currency string. If `config.showPrefix` is `false`, the currency symbol is removed.
  *
- * @example
+ * @example Format a value in USD with prefix
  * ```typescript
  * const formatted = formatToCurrency(1234.56, "USD", { showPrefix: true });
  * console.log(formatted); // "$1,234.56"
- *
+ * ```
+ * @example Format a value in USD without prefix
+ * ```typescript
  * const withoutPrefix = formatToCurrency(1234.56, "USD", { showPrefix: false });
  * console.log(withoutPrefix); // "1,234.56"
- *
+ * ```
+ * @example Format a value in BRL with prefix
+ * ```typescript
  * const formattedBRL = formatToCurrency(1234.56, "BRL", { showPrefix: true });
  * console.log(formattedBRL); // "R$ 1.234,56"
- *
+ * ```
+ * @example Format a value in BRL without prefix
+ * ```typescript
  * const withoutPrefixBRL = formatToCurrency(1234.56, "BRL", { showPrefix: false });
  * console.log(withoutPrefixBRL); // "1.234,56"
  * ```
  */
-declare const formatToCurrency: FormatToCurrency;
+declare function formatToCurrency(value: number, currency: Currencies, config?: {
+    showPrefix?: boolean;
+}): string;
 export { formatToCurrency };
 //# sourceMappingURL=formatToCurrency.d.ts.map

package/dist/formats/formatToCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToCurrency.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,KAAK,UAAU,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAEjD,KAAK,MAAM,GAAG;IACZ,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,KAAK,gBAAgB,GAAG,CACtB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE,MAAM,KACZ,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,gBAmBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatToCurrency.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,KAAK,UAAU,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,iBAAS,gBAAgB,CACvB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,MAAM,CAiBR;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToCurrency.js

@@ -1,41 +1,48 @@
 import { countryCurrencies } from "@arkyn/templates";
-import { removeCurrencySymbols } from "../services/removeCurrencySymbols";
+import { removeCurrencySymbols } from "../utilities/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`.
+ * @param {number} value - The numeric value to be formatted.
+ * @param {Currencies} currency - The currency code used to determine the formatting style.
+ * @param {object} [config] - Optional configuration object.
+ * @param {boolean} [config.showPrefix=true] - 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.
+ * @returns {string} A formatted currency string. If `config.showPrefix` is `false`, the currency symbol is removed.
  *
- * @example
+ * @example Format a value in USD with prefix
  * ```typescript
  * const formatted = formatToCurrency(1234.56, "USD", { showPrefix: true });
  * console.log(formatted); // "$1,234.56"
- *
+ * ```
+ * @example Format a value in USD without prefix
+ * ```typescript
  * const withoutPrefix = formatToCurrency(1234.56, "USD", { showPrefix: false });
  * console.log(withoutPrefix); // "1,234.56"
- *
+ * ```
+ * @example Format a value in BRL with prefix
+ * ```typescript
  * const formattedBRL = formatToCurrency(1234.56, "BRL", { showPrefix: true });
  * console.log(formattedBRL); // "R$ 1.234,56"
- *
+ * ```
+ * @example Format a value in BRL without prefix
+ * ```typescript
  * const withoutPrefixBRL = formatToCurrency(1234.56, "BRL", { showPrefix: false });
  * console.log(withoutPrefixBRL); // "1.234,56"
  * ```
  */
-const formatToCurrency = (value, currency, config = { showPrefix: true }) => {
-    if (!countryCurrencies[currency]) {
+function formatToCurrency(value, currency, config) {
+    if (!countryCurrencies?.[currency]) {
         throw new Error("Unsupported currency code");
     }
+    const showPrefix = config?.showPrefix ?? true;
     const { countryCurrency, countryLanguage } = countryCurrencies[currency];
     const format = new Intl.NumberFormat(countryLanguage, {
         style: "currency",
         currency: countryCurrency,
     }).format(value);
-    return config.showPrefix
+    return showPrefix
         ? format.replace(/\s/g, " ")
         : removeCurrencySymbols(format).replace(/\s/g, " ");
-};
+}
 export { formatToCurrency };