@arkyn/shared 1.4.57 → 1.5.0

package/dist/formats/formatBrazilianDateHour.d.ts

@@ -0,0 +1,3 @@
+declare function formatBrazilianDateHour(date: string, hour: string): Date;
+export { formatBrazilianDateHour };
+//# sourceMappingURL=formatBrazilianDateHour.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatBrazilianDateHour.d.ts","sourceRoot":"","sources":["../../src/formats/formatBrazilianDateHour.ts"],"names":[],"mappings":"AAEA,iBAAS,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAY1D;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/formats/formatBrazilianDateHour.js

@@ -0,0 +1,12 @@
+import { regex } from "../validations/regex";
+function formatBrazilianDateHour(date, hour) {
+    if (regex.HOUR.test(hour) === false)
+        throw new Error("Invalid hour format");
+    const [day, month, year] = date.split("/").map(Number);
+    const dateHour = new Date(`${year}-${month}-${day}`);
+    const [hours, minutes] = hour.split(":").map(Number);
+    dateHour.setUTCHours(hours);
+    dateHour.setUTCMinutes(minutes);
+    return dateHour;
+}
+export { formatBrazilianDateHour };

package/dist/formats/formatBrazilianDateToDate.d.ts

@@ -0,0 +1,3 @@
+declare function formatBrazilianDateToDate(brazilianData: string): Date;
+export { formatBrazilianDateToDate };
+//# sourceMappingURL=formatBrazilianDateToDate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatBrazilianDateToDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatBrazilianDateToDate.ts"],"names":[],"mappings":"AAEA,iBAAS,yBAAyB,CAAC,aAAa,EAAE,MAAM,QAQvD;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/formats/formatBrazilianDateToDate.js

@@ -0,0 +1,9 @@
+import { regex } from "../validations/regex";
+function formatBrazilianDateToDate(brazilianData) {
+    if (regex.DATE.test(brazilianData) === false)
+        throw new Error("Invalid date format");
+    const [day, month, year] = brazilianData.split("/").map(Number);
+    const formattedDate = `${year}-${month}-${day}`;
+    return new Date(formattedDate);
+}
+export { formatBrazilianDateToDate };

package/dist/formats/formatDateHour.d.ts

@@ -0,0 +1,3 @@
+declare function formatDateHour(date: string, hour: string): Date;
+export { formatDateHour };
+//# sourceMappingURL=formatDateHour.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatDateHour.d.ts","sourceRoot":"","sources":["../../src/formats/formatDateHour.ts"],"names":[],"mappings":"AAEA,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAUjD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/formats/formatDateHour.js

@@ -0,0 +1,11 @@
+import { regex } from "../validations/regex";
+function formatDateHour(date, hour) {
+    if (regex.HOUR.test(hour) === false)
+        throw new Error("Invalid hour format");
+    const dateHour = new Date(date);
+    const [hours, minutes] = hour.split(":").map(Number);
+    dateHour.setUTCHours(hours);
+    dateHour.setUTCMinutes(minutes);
+    return dateHour;
+}
+export { formatDateHour };

package/dist/formats/formatJsonObject.d.ts

@@ -1,33 +1,3 @@
-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;
+declare function formatJsonObject(obj: 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,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,iBAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6C/D;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonObject.js

@@ -1,76 +1,35 @@
-/**
- * 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) => {
+function 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 + "]";
-            }
+            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);
-            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 + "}";
-            }
+            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") {
@@ -86,5 +45,5 @@ const formatJsonObject = (obj, indentLevel) => {
         formattedString += obj;
     }
     return formattedString;
-};
+}
 export { formatJsonObject };

package/dist/formats/formatJsonString.d.ts

@@ -1,39 +1,3 @@
-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;
+declare function formatJsonString(jsonString: string): string;
 export { formatJsonString };
 //# sourceMappingURL=formatJsonString.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"formatJsonString.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonString.ts"],"names":[],"mappings":"AAEA,iBAAS,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonString.js

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

package/dist/formats/formatToBRL.d.ts

@@ -0,0 +1,3 @@
+declare function formatToBRL(value: number, showPrefix?: boolean): string;
+export { formatToBRL };
+//# sourceMappingURL=formatToBRL.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatToBRL.d.ts","sourceRoot":"","sources":["../../src/formats/formatToBRL.ts"],"names":[],"mappings":"AAAA,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,UAAO,UAOpD;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToBRL.js

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

package/dist/formats/formatToCNPJ.d.ts

@@ -0,0 +1,3 @@
+declare function formatToCNPJ(value: string): string;
+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,iBAAS,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO3C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/formats/formatToCNPJ.js

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

package/dist/formats/formatToCPF.d.ts

@@ -0,0 +1,3 @@
+declare function formatToCPF(value: string): string;
+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,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCPF.js

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

package/dist/formats/formatToCep.d.ts

@@ -1,29 +1,3 @@
-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;
+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":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;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":"AAAA,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCep.js

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

package/dist/formats/formatToCpfCnpj.d.ts

@@ -1,24 +1,3 @@
-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;
+declare function formatToCpfCnpj(value: string): string;
 export { formatToCpfCnpj };
 //# sourceMappingURL=formatToCpfCnpj.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"formatToCpfCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpfCnpj.ts"],"names":[],"mappings":"AAGA,iBAAS,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/formats/formatToCpfCnpj.js

@@ -1,33 +1,13 @@
-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) => {
+import { formatToCNPJ } from "./formatToCNPJ";
+import { formatToCPF } from "./formatToCPF";
+function formatToCpfCnpj(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);
     }
-    throw new Error("Invalid CPF or CNPJ length");
-};
+    return value;
+}
 export { formatToCpfCnpj };

package/dist/formats/formatToEllipsis.d.ts

@@ -1,16 +1,3 @@
-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..."
- */
-declare const formatToEllipsis: FormatToEllipsisFunction;
+declare function formatToEllipsis(text: string, size?: number): string;
 export { formatToEllipsis };
 //# sourceMappingURL=formatToEllipsis.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToEllipsis.d.ts","sourceRoot":"","sources":["../../src/formats/formatToEllipsis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D;;;;;;;;;;;GAWG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatToEllipsis.d.ts","sourceRoot":"","sources":["../../src/formats/formatToEllipsis.ts"],"names":[],"mappings":"AAAA,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAEzD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToEllipsis.js

@@ -1,21 +1,4 @@
-/**
- * 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 = (text, maxLength) => {
-    if (text.length > maxLength) {
-        let trimmedText = text.substring(0, maxLength).trimEnd();
-        trimmedText = trimmedText.replace(/[.,!?;:]$/, "");
-        return `${trimmedText}...`;
-    }
-    return text;
-};
+function formatToEllipsis(text, size = 40) {
+    return text.length > size ? `${text.substring(0, size)}...` : text;
+}
 export { formatToEllipsis };

package/dist/formats/formatToHiddenDigits.d.ts

@@ -1,32 +1,4 @@
-import type { FormatToHiddenDigitsFunction } from "@arkyn/types";
-/**
- * Formats a string by hiding specific digits within a given range.
- *
- * This function takes a string input and replaces digits within a specified range
- * with a hiding character (e.g., "*"). Non-digit characters remain unchanged.
- *
- * @param value - The input string to be formatted.
- * @param options - Configuration options for formatting.
- * @param options.range - The range of digits to hide. It can be:
- *   - A single number (e.g., `3`), which hides the first `n` digits if positive,
- *     or the last `n` digits if negative.
- *   - A tuple `[start, end]` specifying the range of digits to hide (inclusive).
- *   - Defaults to `3`, hiding the first three digits.
- * @param options.hider - The character used to hide digits. Defaults to `"*"`.
- *
- * @returns The formatted string with specified digits hidden.
- *
- * @example
- * ```typescript
- * import { formatToHiddenDigits } from "./formatToHiddenDigits";
- *
- * formatToHiddenDigits("123-456-7890", { range: 3 });
- * // Output: "***-456-7890"
- *
- * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
- * // Output: "123-###-7890"
- * ```
- */
-declare const formatToHiddenDigits: FormatToHiddenDigitsFunction;
+import type { FormatToHiddenDigitsOptions } from "@arkyn/types";
+declare const formatToHiddenDigits: (value: string, options?: FormatToHiddenDigitsOptions) => string;
 export { formatToHiddenDigits };
 //# sourceMappingURL=formatToHiddenDigits.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToHiddenDigits.d.ts","sourceRoot":"","sources":["../../src/formats/formatToHiddenDigits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AA+CjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,oBAAoB,EAAE,4BAU3B,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"formatToHiddenDigits.d.ts","sourceRoot":"","sources":["../../src/formats/formatToHiddenDigits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAKhE,QAAA,MAAM,oBAAoB,GACxB,OAAO,MAAM,EACb,UAAS,2BAAgC,KACxC,MAUF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}