@arkyn/shared 2.0.1-beta.0 → 2.0.1-beta.2

package/dist/formats/formatDate.d.ts

@@ -0,0 +1,43 @@
+import type { FormatDateFunction } from "@arkyn/types";
+/**
+ * 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"
+ * ```
+ */
+declare const formatDate: FormatDateFunction;
+export { formatDate };
+//# sourceMappingURL=formatDate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatDate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAqBvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAiCjB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/formats/formatDate.js

@@ -0,0 +1,77 @@
+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()),
+    };
+    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 = (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/dist/formats/formatJsonObject.d.ts

@@ -0,0 +1,33 @@
+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"
+ * //   ]
+ * // }
+ * ```
+ */
+declare const formatJsonObject: FormatJsonObjectFunction;
+export { formatJsonObject };
+//# sourceMappingURL=formatJsonObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatJsonObject.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAuDvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonObject.js

@@ -0,0 +1,90 @@
+/**
+ * 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 = (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/dist/formats/formatJsonString.d.ts

@@ -0,0 +1,39 @@
+import type { FormatJsonStringFunction } from "@arkyn/types";
+/**
+ * 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)
+ * // ""
+ * ```
+ */
+declare const formatJsonString: FormatJsonStringFunction;
+export { formatJsonString };
+//# sourceMappingURL=formatJsonString.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatJsonString.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonString.js

@@ -0,0 +1,46 @@
+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 = (jsonString) => {
+    try {
+        const jsonObject = JSON.parse(jsonString);
+        return formatJsonObject(jsonObject, 0);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON string \n ${error}`);
+    }
+};
+export { formatJsonString };

package/dist/formats/formatToCep.d.ts

@@ -0,0 +1,29 @@
+import type { FormatToCepFunction } from "@arkyn/types";
+/**
+ * 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"
+ * }
+ * ```
+ */
+declare const formatToCep: FormatToCepFunction;
+export { formatToCep };
+//# sourceMappingURL=formatToCep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToCep.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCep.js

@@ -0,0 +1,34 @@
+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 = (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/dist/formats/formatToCnpj.d.ts

@@ -0,0 +1,30 @@
+import type { FormatToCnpjFunction } from "@arkyn/types";
+/**
+ * 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"
+ * }
+ * ```
+ */
+declare const formatToCnpj: FormatToCnpjFunction;
+export { formatToCnpj };
+//# sourceMappingURL=formatToCnpj.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCnpj.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAMnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/formats/formatToCnpj.js

@@ -0,0 +1,35 @@
+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 = (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/dist/formats/formatToCpf.d.ts

@@ -0,0 +1,30 @@
+import type { FormatToCpfFunction } from "@arkyn/types";
+/**
+ * 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"
+ * }
+ *
+ * ```
+ */
+declare const formatToCpf: FormatToCpfFunction;
+export { formatToCpf };
+//# sourceMappingURL=formatToCpf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToCpf.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCpf.js

@@ -0,0 +1,35 @@
+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 = (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/dist/formats/formatToCpfCnpj.d.ts

@@ -0,0 +1,24 @@
+import type { FormatToCpfCnpjFunction } from "@arkyn/types";
+/**
+ * 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"
+ * ```
+ */
+declare const formatToCpfCnpj: FormatToCpfCnpjFunction;
+export { formatToCpfCnpj };
+//# sourceMappingURL=formatToCpfCnpj.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToCpfCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpfCnpj.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,eAAe,EAAE,uBAStB,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/formats/formatToCpfCnpj.js

@@ -0,0 +1,33 @@
+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 = (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/dist/formats/formatToCurrency.d.ts

@@ -0,0 +1,29 @@
+import type { FormatToCurrency } from "@arkyn/types";
+/**
+ * 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"
+ * ```
+ */
+declare const formatToCurrency: FormatToCurrency;
+export { formatToCurrency };
+//# sourceMappingURL=formatToCurrency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToCurrency.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCurrency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIrD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,gBAmBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}