@arkyn/shared 1.5.0 → 1.5.1

package/LICENSE.txt

@@ -0,0 +1,24 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   Copyright 2025 Lucas Gonçalves
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+For more information or to contribute, visit:
+https://github.com/Lucas-Eduardo-Goncalves

package/README.md

@@ -0,0 +1,113 @@
+The `@arkyn/shared` package provides reusable utilities such as formatting functions, generators, services, and validations. It is designed to be used across different parts of a project, offering common and practical solutions to streamline development.
+
+---
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install @arkyn/shared
+```
+
+---
+
+## Features
+
+### Formatting
+
+- **`formatDate(date: Date): string`**  
+  Formats a date into a readable string.
+
+- **`formatJsonObject(obj: object): string`**  
+  Converts a JSON object into a formatted string.
+
+- **`formatJsonString(json: string): object`**  
+  Converts a JSON string into an object.
+
+- **`formatToCep(value: string): string`**  
+  Formats a string into the CEP format (`XXXXX-XXX`).
+
+- **`formatToCnpj(value: string): string`**  
+  Formats a string into the CNPJ format (`XX.XXX.XXX/XXXX-XX`).
+
+- **`formatToCpf(value: string): string`**  
+  Formats a string into the CPF format (`XXX.XXX.XXX-XX`).
+
+- **`formatToCpfCnpj(value: string): string`**  
+  Formats a string into either CPF or CNPJ format, depending on its length.
+
+- **`formatToCurrency(value: number): string`**  
+  Converts a number into a currency format.
+
+- **`formatToEllipsis(value: string, maxLength: number): string`**  
+  Truncates a string and appends an ellipsis if it exceeds the maximum length.
+
+- **`formatToHiddenDigits(value: string): string`**  
+  Masks part of a string by replacing it with asterisks.
+
+- **`formatToPhone(value: string): string`**  
+  Formats a string into a phone number format.
+
+---
+
+### Generators
+
+- **`generateColorByString(value: string): string`**  
+  Generates a hexadecimal color based on a string.
+
+- **`generateId(): string`**  
+  Generates a unique identifier.
+
+- **`generateSlug(value: string): string`**  
+  Converts a string into a URL-friendly slug.
+
+---
+
+### Services
+
+- **`calculateCardInstallment(total: number, installments: number): number[]`**  
+  Calculates the installment values for a given total.
+
+- **`maskSensitiveData(data: string): string`**  
+  Masks sensitive data in a string.
+
+- **`removeNonNumeric(value: string): string`**  
+  Removes all non-numeric characters from a string.
+
+- **`truncateLargeFields(obj: object, maxLength: number): object`**  
+  Truncates large fields in an object to a specified maximum length.
+
+---
+
+### Validations
+
+- **`validateCep(value: string): boolean`**  
+  Validates whether a string is a valid CEP.
+
+- **`validateCnpj(value: string): boolean`**  
+  Validates whether a string is a valid CNPJ.
+
+- **`validateCpf(value: string): boolean`**  
+  Validates whether a string is a valid CPF.
+
+- **`validateDate(value: string): boolean`**  
+  Validates whether a string is a valid date.
+
+- **`validatePhone(value: string): boolean`**  
+  Validates whether a string is a valid phone number.
+
+- **`validateRg(value: string): boolean`**  
+  Validates whether a string is a valid ID (RG).
+
+---
+
+## Contribution
+
+Contributions are welcome! Feel free to open issues or submit pull requests to improve the project.
+
+---
+
+## License
+
+This project is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.

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

@@ -1,3 +1,33 @@
-declare function formatJsonObject(obj: any, indentLevel: number): string;
+import type { FormatJsonObjectFunction } from "@arkyn/types";
+/**
+ * Formats a JSON object into a human-readable string with proper indentation.
+ *
+ * @param obj - The JSON object or value to format. It can be an object, array, string, or primitive value.
+ * @param indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
+ * @returns A formatted string representation of the JSON object.
+ *
+ * @remarks
+ * - If the input is an object, it will be formatted with keys and values properly indented.
+ * - If the input is an array, each element will be formatted and indented on a new line.
+ * - If the input is a string that can be parsed as JSON, it will attempt to parse and format it.
+ * - Primitive values (e.g., numbers, booleans, null) will be converted to their string representation.
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
+ * const formatted = formatJsonObject(obj, 0);
+ * console.log(formatted);
+ * // Output:
+ * // {
+ * //   "name": "John",
+ * //   "age": 30,
+ * //   "hobbies": [
+ * //     "reading",
+ * //     "gaming"
+ * //   ]
+ * // }
+ * ```
+ */
+declare const formatJsonObject: FormatJsonObjectFunction;
 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,iBAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6C/D;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"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

@@ -1,35 +1,76 @@
-function formatJsonObject(obj, indentLevel) {
+/**
+ * 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)) {
-            formattedString += "[\n";
-            obj.forEach((item, index) => {
-                formattedString +=
-                    indent + "  " + formatJsonObject(item, indentLevel + 1);
-                if (index < obj.length - 1) {
-                    formattedString += ",";
-                }
-                formattedString += "\n";
-            });
-            formattedString += indent + "]";
+            if (obj.length === 0) {
+                // Caso especial para arrays vazios
+                formattedString += "[]";
+            }
+            else {
+                formattedString += "[\n";
+                obj.forEach((item, index) => {
+                    formattedString +=
+                        indent + "  " + formatJsonObject(item, indentLevel + 1);
+                    if (index < obj.length - 1) {
+                        formattedString += ",";
+                    }
+                    formattedString += "\n";
+                });
+                formattedString += indent + "]";
+            }
         }
         else {
-            formattedString += "{\n";
             const keys = Object.keys(obj);
-            keys.forEach((key, index) => {
-                formattedString +=
-                    indent +
-                        '  "' +
-                        key +
-                        '": ' +
-                        formatJsonObject(obj[key], indentLevel + 1);
-                if (index < keys.length - 1) {
-                    formattedString += ",";
-                }
-                formattedString += "\n";
-            });
-            formattedString += indent + "}";
+            if (keys.length === 0) {
+                // Caso especial para objetos vazios
+                formattedString += "{}";
+            }
+            else {
+                formattedString += "{\n";
+                keys.forEach((key, index) => {
+                    formattedString +=
+                        indent +
+                            '  "' +
+                            key +
+                            '": ' +
+                            formatJsonObject(obj[key], indentLevel + 1);
+                    if (index < keys.length - 1) {
+                        formattedString += ",";
+                    }
+                    formattedString += "\n";
+                });
+                formattedString += indent + "}";
+            }
         }
     }
     else if (typeof obj === "string") {
@@ -45,5 +86,5 @@ function formatJsonObject(obj, indentLevel) {
         formattedString += obj;
     }
     return formattedString;
-}
+};
 export { formatJsonObject };

package/dist/formats/formatJsonString.d.ts

@@ -1,3 +1,39 @@
-declare function formatJsonString(jsonString: string): string;
+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

@@ -1 +1 @@
-{"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"}
+{"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

@@ -1,12 +1,46 @@
 import { formatJsonObject } from "./formatJsonObject";
-function formatJsonString(jsonString) {
+/**
+ * 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) {
-        console.error("Invalid JSON string:", error);
-        return "";
+        throw new Error(`Invalid JSON string \n ${error}`);
     }
-}
+};
 export { formatJsonString };

package/dist/formats/formatToCep.d.ts

@@ -1,3 +1,29 @@
-declare function formatToCep(value: string): string;
+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

@@ -1 +1 @@
-{"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"}
+{"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

@@ -1,9 +1,34 @@
-function formatToCep(value) {
-    const cleaned = value.replace(/\D/g, "");
+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) {
+    if (match)
         return `${match[1]}-${match[2]}`;
-    }
-    return value;
-}
+    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 };