@arkyn/shared 3.0.1-beta.8 → 3.0.1-beta.80

package/dist/validations/validateDate.d.ts

@@ -1,34 +0,0 @@
-type ValidateDateConfig = {
-    inputFormat?: "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
-    minYear?: number;
-    maxYear?: number;
-};
-type ValidateDateFunction = (rawDate: string, config?: ValidateDateConfig) => boolean;
-/**
- * Validates a date string based on the provided format and configuration.
- *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
- *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
- *
- * @example
- * ```typescript
- * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
- * ```
- */
-declare const validateDate: ValidateDateFunction;
-export { validateDate };
-//# sourceMappingURL=validateDate.d.ts.map

package/dist/validations/validateDate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,oBAAoB,GAAG,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,kBAAkB,KACxB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateDate.js

@@ -1,73 +0,0 @@
-/**
- * Validates a date string based on the provided format and configuration.
- *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
- *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
- *
- * @example
- * ```typescript
- * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
- * ```
- */
-const validateDate = (rawDate, config) => {
-    let day, month, year;
-    const inputFormat = config?.inputFormat || "DD/MM/YYYY";
-    const minYear = config?.minYear || 1900;
-    const maxYear = config?.maxYear || 3000;
-    if (inputFormat === "DD/MM/YYYY") {
-        const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, day, month, year] = rawDate.match(dateRegex) || [];
-    }
-    else if (inputFormat === "MM-DD-YYYY") {
-        const dateRegex = /^(\d{2})-(\d{2})-(\d{4})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, month, day, year] = rawDate.match(dateRegex) || [];
-    }
-    else if (inputFormat === "YYYY-MM-DD") {
-        const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, year, month, day] = rawDate.match(dateRegex) || [];
-    }
-    else {
-        throw new Error("Invalid date format");
-    }
-    const dayNum = parseInt(day, 10);
-    const monthNum = parseInt(month, 10);
-    const yearNum = parseInt(year, 10);
-    if (dayNum < 1 || dayNum > 31)
-        return false;
-    if (monthNum < 1 || monthNum > 12)
-        return false;
-    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    if (monthNum === 2) {
-        const isLeapYear = (yearNum % 4 === 0 && yearNum % 100 !== 0) || yearNum % 400 === 0;
-        if (dayNum > (isLeapYear ? 29 : 28))
-            return false;
-    }
-    else if (dayNum > daysInMonth[monthNum - 1]) {
-        return false;
-    }
-    if (yearNum < minYear || yearNum > maxYear)
-        return false;
-    const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
-    return isValidDate;
-};
-export { validateDate };

package/dist/validations/validatePassword.d.ts

@@ -1,21 +0,0 @@
-type ValidatePasswordFunction = (rawPassword: string) => boolean;
-/**
- * Validates a password based on the following rules:
- * - At least 8 characters
- * - At least 1 uppercase letter
- * - At least 1 letter (any case)
- * - At least 1 number
- * - At least 1 special character
- *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validatePassword("Senha@123"); // true
- * validatePassword("senha123");  // false (no uppercase, no special char)
- * ```
- */
-declare const validatePassword: ValidatePasswordFunction;
-export { validatePassword };
-//# sourceMappingURL=validatePassword.d.ts.map

package/dist/validations/validatePassword.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAkBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/validations/validatePassword.js

@@ -1,34 +0,0 @@
-/**
- * Validates a password based on the following rules:
- * - At least 8 characters
- * - At least 1 uppercase letter
- * - At least 1 letter (any case)
- * - At least 1 number
- * - At least 1 special character
- *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validatePassword("Senha@123"); // true
- * validatePassword("senha123");  // false (no uppercase, no special char)
- * ```
- */
-const validatePassword = (rawPassword) => {
-    if (!rawPassword)
-        return false;
-    const hasMinLength = rawPassword.length >= 8;
-    const hasUppercase = /[A-Z]/.test(rawPassword);
-    const hasLetter = /[a-z]/.test(rawPassword);
-    const hasNumber = /\d/.test(rawPassword);
-    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>_\-+=~`[\]\\\/]/.test(rawPassword);
-    return [
-        hasMinLength,
-        hasUppercase,
-        hasLetter,
-        hasNumber,
-        hasSpecialChar,
-    ].every((condition) => condition);
-};
-export { validatePassword };

package/dist/validations/validatePhone.d.ts

@@ -1,29 +0,0 @@
-type ValidatePhoneFunction = (rawPhone: string) => boolean;
-/**
- * Validates a phone number against a list of country-specific formats.
- *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
- *
- * @example
- * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
- * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
- * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
- * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
- * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
- * ```
- */
-declare const validatePhone: ValidatePhoneFunction;
-export { validatePhone };
-//# sourceMappingURL=validatePhone.d.ts.map

package/dist/validations/validatePhone.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -1,44 +0,0 @@
-import { countries } from "@arkyn/templates";
-/**
- * Validates a phone number against a list of country-specific formats.
- *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
- *
- * @example
- * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
- * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
- * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
- * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
- * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
- * ```
- */
-const validatePhone = (rawPhone) => {
-    for (const country of countries) {
-        const countryCode = country.code;
-        const prefix = country.prefix ? `-${country.prefix}` : "";
-        const digitCount = country.mask.replace(/[^_]/g, "").length;
-        if (country.iso === "BR") {
-            const brazilRegex = new RegExp(`^\\${countryCode} \\d{2}9?\\d{8}$`);
-            if (brazilRegex.test(rawPhone))
-                return true;
-            continue;
-        }
-        const regex = new RegExp(`^\\${countryCode}${prefix} \\d{${digitCount}}$`);
-        if (regex.test(rawPhone))
-            return true;
-    }
-    return false;
-};
-export { validatePhone };

package/dist/validations/validateRg.d.ts

@@ -1,22 +0,0 @@
-type ValidateRgFunction = (rawRg: string) => boolean;
-/**
- * Validates a Brazilian RG (Registro Geral) in a generic way.
- *
- * This function does a basic structure validation:
- * - Removes non-alphanumeric characters.
- * - Ensures length is reasonable (7–9 digits).
- * - Optionally allows for a final letter (verifier).
- *
- * @param rawRg - RG string, possibly formatted.
- * @returns `true` if format seems valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validateRg("12.345.678-9"); // true
- * validateRg("MG-12.345.678"); // false (not supported)
- * validateRg("12345678X"); // true
- * ```
- */
-declare const validateRg: ValidateRgFunction;
-export { validateRg };
-//# sourceMappingURL=validateRg.d.ts.map

package/dist/validations/validateRg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAajB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/validations/validateRg.js

@@ -1,31 +0,0 @@
-/**
- * Validates a Brazilian RG (Registro Geral) in a generic way.
- *
- * This function does a basic structure validation:
- * - Removes non-alphanumeric characters.
- * - Ensures length is reasonable (7–9 digits).
- * - Optionally allows for a final letter (verifier).
- *
- * @param rawRg - RG string, possibly formatted.
- * @returns `true` if format seems valid, otherwise `false`.
- *
- * @example
- * ```ts
- * validateRg("12.345.678-9"); // true
- * validateRg("MG-12.345.678"); // false (not supported)
- * validateRg("12345678X"); // true
- * ```
- */
-const validateRg = (rawRg) => {
-    if (!rawRg)
-        return false;
-    const validFormat = /^[0-9a-zA-Z.-]+$/.test(rawRg);
-    if (!validFormat)
-        return false;
-    const rg = rawRg.replace(/[^a-zA-Z0-9]/g, "");
-    if (rg.length < 7 || rg.length > 9)
-        return false;
-    const isValidFormat = /^[0-9]{7,8}[0-9Xx]?$/.test(rg);
-    return isValidFormat;
-};
-export { validateRg };

package/src/formats/formatDate.ts

@@ -1,92 +0,0 @@
-type InputFormatTypes = "brazilianDate" | "isoDate" | "timestamp";
-
-type FormatDateFunction = (
-  date: string[], // [date: string, time?: string]
-  inputFormat: InputFormatTypes,
-  outputFormat: string,
-  timezone?: number
-) => string;
-
-function formatDateString(date: Date, format: string): string {
-  const pad = (num: number) => num.toString().padStart(2, "0");
-
-  const replacements: Record<string, string> = {
-    YYYY: date.getFullYear().toString(),
-    YY: date.getFullYear().toString().slice(-2),
-    MM: pad(date.getMonth() + 1),
-    DD: pad(date.getDate()),
-    hh: pad(date.getHours()),
-    mm: pad(date.getMinutes()),
-    ss: pad(date.getSeconds()),
-  };
-
-  return format.replace(
-    /YYYY|YY|MM|DD|hh|mm|ss/g,
-    (match) => replacements[match]
-  );
-}
-
-/**
- * Formats a date and time string based on the provided input and output formats.
- *
- * @param {[string, string]} dateTime - An array containing the date and optional time.
- *   - The first element is the date string.
- *   - The second element is the time string (default is "00:00:00").
- * @param {"brazilianDate" | "isoDate" | "timestamp"} inputFormat - The format of the input date.
- *   - "brazilianDate": Expects the date in "DD/MM/YYYY" format.
- *   - "isoDate": Expects the date in "YYYY-MM-DD" format.
- *   - "timestamp": Expects the date in "YYYY/MM/DD" format.
- * @param {string} outputFormat - The desired output format for the date.
- *   - Use placeholders like "YYYY", "MM", "DD", "hh", "mm", "ss" to define the format.
- * @param {number} [timezone=0] - The timezone offset in hours to apply to the date.
- *   - Defaults to 0 (UTC).
- * @returns {string} The formatted date string based on the output format.
- * @throws {Error} If the input format is invalid.
- * @throws {Error} If the date is invalid.
- *
- * @example
- * // Format a Brazilian date to ISO format
- * formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm:ss");
- * // Returns: "2023-12-25 15:30:00"
- *
- * @example
- * // Format an ISO date to a custom format with timezone adjustment
- * formatDate(["2023-12-25", "15:30:00"], "isoDate", "DD/MM/YYYY hh:mm:ss", -3);
- * // Returns: "25/12/2023 12:30:00"
- */
-
-const formatDate: FormatDateFunction = (
-  [date, time = "00:00:00"],
-  inputFormat,
-  outputFormat,
-  timezone = 0
-) => {
-  const dateParts = date.split(/[-/]/).map(Number);
-  const timeParts = time.split(".")[0].split(":").map(Number);
-
-  let day, month, year;
-  const [hours = 0, minutes = 0, seconds = 0] = timeParts;
-
-  switch (inputFormat) {
-    case "brazilianDate":
-      [day, month, year] = dateParts;
-      break;
-    case "isoDate":
-      [year, month, day] = dateParts;
-      break;
-    case "timestamp":
-      [year, month, day] = dateParts.map(Number);
-      break;
-    default:
-      throw new Error("Invalid input format");
-  }
-
-  const formattedDate = new Date(year, month - 1, day, hours, minutes, seconds);
-  if (isNaN(formattedDate.getTime())) throw new Error("Invalid date");
-
-  formattedDate.setUTCHours(formattedDate.getUTCHours() + timezone);
-
-  return formatDateString(formattedDate, outputFormat);
-};
-
-export { formatDate };

package/src/formats/formatJsonObject.ts

@@ -1,90 +0,0 @@
-type FormatJsonObjectFunction = (jsonString: any, identLevel: number) => string;
-
-/**
- * Formats a JSON object into a human-readable string with proper indentation.
- *
- * @param obj - The JSON object or value to format. It can be an object, array, string, or primitive value.
- * @param indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
- * @returns A formatted string representation of the JSON object.
- *
- * @remarks
- * - If the input is an object, it will be formatted with keys and values properly indented.
- * - If the input is an array, each element will be formatted and indented on a new line.
- * - If the input is a string that can be parsed as JSON, it will attempt to parse and format it.
- * - Primitive values (e.g., numbers, booleans, null) will be converted to their string representation.
- *
- * @example
- * ```typescript
- * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
- * const formatted = formatJsonObject(obj, 0);
- * console.log(formatted);
- * // Output:
- * // {
- * //   "name": "John",
- * //   "age": 30,
- * //   "hobbies": [
- * //     "reading",
- * //     "gaming"
- * //   ]
- * // }
- * ```
- */
-
-const formatJsonObject: FormatJsonObjectFunction = (obj, indentLevel) => {
-  const indent = "  ".repeat(indentLevel);
-  let formattedString = "";
-
-  if (typeof obj === "object" && obj !== null) {
-    if (Array.isArray(obj)) {
-      if (obj.length === 0) {
-        // Caso especial para arrays vazios
-        formattedString += "[]";
-      } else {
-        formattedString += "[\n";
-        obj.forEach((item, index) => {
-          formattedString +=
-            indent + "  " + formatJsonObject(item, indentLevel + 1);
-          if (index < obj.length - 1) {
-            formattedString += ",";
-          }
-          formattedString += "\n";
-        });
-        formattedString += indent + "]";
-      }
-    } else {
-      const keys = Object.keys(obj);
-      if (keys.length === 0) {
-        // Caso especial para objetos vazios
-        formattedString += "{}";
-      } else {
-        formattedString += "{\n";
-        keys.forEach((key, index) => {
-          formattedString +=
-            indent +
-            '  "' +
-            key +
-            '": ' +
-            formatJsonObject(obj[key], indentLevel + 1);
-          if (index < keys.length - 1) {
-            formattedString += ",";
-          }
-          formattedString += "\n";
-        });
-        formattedString += indent + "}";
-      }
-    }
-  } else if (typeof obj === "string") {
-    try {
-      const parsedObj = JSON.parse(obj);
-      formattedString += formatJsonObject(parsedObj, indentLevel);
-    } catch {
-      formattedString += '"' + obj + '"';
-    }
-  } else {
-    formattedString += obj;
-  }
-
-  return formattedString;
-};
-
-export { formatJsonObject };

package/src/formats/formatJsonString.ts

@@ -1,50 +0,0 @@
-import { formatJsonObject } from "./formatJsonObject";
-
-type FormatJsonStringFunction = (jsonString: string) => string;
-
-/**
- * Formats a JSON string into a more readable format.
- *
- * This function attempts to parse the provided JSON string into a JavaScript object,
- * and then formats it using the `formatJsonObject` function. If the input string
- * is not a valid JSON, it logs an error to the console and returns an empty string.
- *
- * @param jsonString - The JSON string to be formatted.
- * @returns A formatted JSON string, or an empty string if the input is invalid.
- *
- * @throws Will log an error to the console if the input is not a valid JSON string.
- *
- * @example
- * ```typescript
- * const jsonString = '{"name":"John","age":30,"hobbies":["reading","gaming"]}';
- * const formatted = formatJsonString(jsonString);
- * console.log(formatted);
- * // Output:
- * // {
- * //   "name": "John",
- * //   "age": 30,
- * //   "hobbies": [
- * //     "reading",
- * //     "gaming"
- * //   ]
- * // }
-
- * const invalidJsonString = '{"name":"John", "age":30,';
- * const formatted = formatJsonString(invalidJsonString);
- * console.log(formatted);
- * // Output:
- * // (Logs "Invalid JSON string: ..." to the console)
- * // ""
- * ```
- */
-
-const formatJsonString: FormatJsonStringFunction = (jsonString) => {
-  try {
-    const jsonObject = JSON.parse(jsonString);
-    return formatJsonObject(jsonObject, 0);
-  } catch (error) {
-    throw new Error(`Invalid JSON string \n ${error}`);
-  }
-};
-
-export { formatJsonString };

package/src/formats/formatToCep.ts

@@ -1,39 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCepFunction = (value: string) => string;
-
-/**
- * Formats a given string into a Brazilian postal code (CEP) format.
- *
- * The function removes all non-numeric characters from the input string
- * and attempts to format it as a CEP in the pattern `XXXXX-XXX`.
- * If the input does not match the expected format, an error is thrown.
- *
- * @param value - The input string to be formatted as a CEP.
- * @returns The formatted CEP string in the pattern `XXXXX-XXX`.
- * @throws {Error} If the input does not match the expected CEP format.
- *
- * @example
- * ```typescript
- * import { formatToCep } from "./formatToCep";
- *
- * const formattedCep = formatToCep("12345678");
- * console.log(formattedCep); // Output: "12345-678"
- *
- * try {
- *   formatToCep("1234");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CEP format"
- * }
- * ```
- */
-
-const formatToCep: FormatToCepFunction = (value) => {
-  const cleaned = removeNonNumeric(value);
-  const match = cleaned.match(/^(\d{5})(\d{3})$/);
-
-  if (match) return `${match[1]}-${match[2]}`;
-  throw new Error("Invalid CEP format");
-};
-
-export { formatToCep };

package/src/formats/formatToCnpj.ts

@@ -1,40 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCnpjFunction = (value: string) => string;
-
-/**
- * Formats a given string or number into a CNPJ (Cadastro Nacional da Pessoa Jurídica) format.
- *
- * The CNPJ format is: `XX.XXX.XXX/XXXX-XX`, where `X` represents a digit.
- *
- * @param value - The input value to be formatted. It can be a string or number containing the CNPJ digits.
- *                Non-numeric characters will be removed before formatting.
- *
- * @returns A string formatted as a CNPJ.
- *
- * @throws {Error} Throws an error if the input does not contain exactly 14 numeric digits.
- *
- * @example
- * ```typescript
- * import { formatToCnpj } from "./formatToCNPJ";
- *
- * const formattedCnpj = formatToCnpj("12345678000195");
- * console.log(formattedCnpj); // Output: "12.345.678/0001-95"
- *
- * try {
- *   formatToCnpj("12345");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CNPJ length"
- * }
- * ```
- */
-
-const formatToCnpj: FormatToCnpjFunction = (value) => {
-  const cleaned = removeNonNumeric(value);
-  const match = cleaned.match(/^(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/);
-  if (match)
-    return `${match[1]}.${match[2]}.${match[3]}/${match[4]}-${match[5]}`;
-  throw new Error("Invalid CNPJ length");
-};
-
-export { formatToCnpj };

package/src/formats/formatToCpf.ts

@@ -1,40 +0,0 @@
-import { removeNonNumeric } from "../services/removeNonNumeric";
-
-type FormatToCpfFunction = (value: string) => string;
-
-/**
- * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
- * 
- * A CPF is a Brazilian individual taxpayer registry identification format.
- * This function ensures the input is cleaned of non-numeric characters and
- * then formats it into the standard CPF format: `XXX.XXX.XXX-XX`.
- *
- * @param value - The input string to be formatted as a CPF.
- * @returns The formatted CPF string.
- * @throws {Error} If the input string does not match the expected CPF format.
- *
- * @example
- * ```typescript
- * import { formatToCpf } from "./formatToCPF";
- *
- * const formattedCpf = formatToCpf("12345678909");
- * console.log(formattedCpf); // Output: "123.456.789-09"
-
- * try {
- *   const formattedCpf = formatToCpf("12345");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CPF format"
- * }
- * 
- * ```
- */
-
-const formatToCpf: FormatToCpfFunction = (value) => {
-  const cleaned = removeNonNumeric(value);
-  const match = cleaned.match(/^(\d{3})(\d{3})(\d{3})(\d{2})$/);
-
-  if (match) return `${match[1]}.${match[2]}.${match[3]}-${match[4]}`;
-  throw new Error("Invalid CPF format");
-};
-
-export { formatToCpf };