@arkyn/shared 1.4.57 → 1.5.0

package/src/services/calculateCardInstallment.ts

@@ -1,66 +1,21 @@
-import type { CalculateCardInstallmentFunction } from "@arkyn/types";
+import type { CalculateCardInstallmentProps } from "@arkyn/types";
 
-/**
- * Calculates the installment price and total price for a card payment plan.
- *
- * @remarks
- * **Important:** When the interest amount (`fees`) is equal to 0 or the number of installments (`numberInstallments`) is equal to 1, no interest will be charged.
- *
- * @throws Will throw an error if the number of installments is less than or equal to 0.
- * @throws Will throw an error if the fees are less than 0.
- *
- * @param props - The input parameters for the calculation.
- * @param props.cashPrice - The total cash price of the product or service.
- * @param props.numberInstallments - The number of installments for the payment plan.
- * @param props.fees - The interest rate per installment (default is 0.0349).
- *
- * @returns An object containing:
- * - `totalPrice`: The total price to be paid, rounded to two decimal places.
- * - `installmentPrice`: The price of each installment, rounded to two decimal places.
- *
- * @example
- * ```typescript
- * const result = calculateCardInstallment({
- *   cashPrice: 1000,
- *   numberInstallments: 12,
- *   fees: 0.02,
- * });
- * console.log(result);
- * // Output: { totalPrice: 1124.62, installmentPrice: 93.72 }
- * ```
- */
+function calculateCardInstallment(args: CalculateCardInstallmentProps) {
+  const { cash_price, number_installments, fees = 0.0349 } = args;
 
-const calculateCardInstallment: CalculateCardInstallmentFunction = (props) => {
-  const { cashPrice, numberInstallments, fees = 0.0349 } = props;
+  let installment_price = 0;
+  let total_price = 0;
 
-  if (fees === 0 || numberInstallments === 1) {
-    return {
-      totalPrice: cashPrice,
-      installmentPrice: cashPrice / numberInstallments,
-    };
-  }
+  let numerator = Math.pow(1 + fees, number_installments) * fees;
+  let denominator = Math.pow(1 + fees, number_installments) - 1;
 
-  if (numberInstallments <= 0) {
-    throw new Error("Number of installments must be greater than 0");
-  }
-
-  if (fees < 0) {
-    throw new Error("Fees must be greater than or equal to 0");
-  }
-
-  let installmentPrice = 0;
-  let totalPrice = 0;
-
-  let numerator = Math.pow(1 + fees, numberInstallments) * fees;
-  let denominator = Math.pow(1 + fees, numberInstallments) - 1;
-
-  installmentPrice = cashPrice * (numerator / denominator);
-  totalPrice = numberInstallments * installmentPrice;
+  installment_price = cash_price * (numerator / denominator);
+  total_price = number_installments * installment_price;
 
   return {
-    totalPrice: +totalPrice.toFixed(2),
-    installmentPrice: +installmentPrice.toFixed(2),
+    total_price: +total_price.toFixed(2),
+    installment_price: +installment_price.toFixed(2),
   };
-};
+}
 
 export { calculateCardInstallment };

package/src/services/maskSensitiveData.ts

@@ -1,32 +1,7 @@
-import type { MaskSensitiveDataFunction } from "@arkyn/types";
-
-/**
- * Masks sensitive data in a JSON string by replacing the values of specified keys with "****".
- *
- * @param jsonString - The JSON string to be processed.
- * @param sensitiveKeys - An array of keys whose values should be masked. Defaults to `["password", "confirmPassword", "creditCard"]`.
- * @returns A JSON string with sensitive data masked. If the input is not a valid JSON string, it returns the original string.
- *
- * @example
- * ```typescript
- * const jsonString = JSON.stringify({
- *   username: "user123",
- *   password: "secret",
- *   profile: {
- *     creditCard: "1234-5678-9012-3456",
- *   },
- * });
- *
- * const result = maskSensitiveData(jsonString, ["password", "creditCard"]);
- * console.log(result);
- * // Output: '{"username":"user123","password":"****","profile":{"creditCard":"****"}}'
- * ```
- */
-
-const maskSensitiveData: MaskSensitiveDataFunction = (
-  jsonString,
+function maskSensitiveData(
+  jsonString: string,
   sensitiveKeys = ["password", "confirmPassword", "creditCard"]
-) => {
+): string {
   function maskValue(key: string, value: any): any {
     if (sensitiveKeys.includes(key)) return "****";
     return value;
@@ -60,6 +35,6 @@ const maskSensitiveData: MaskSensitiveDataFunction = (
   } catch (error) {
     return jsonString;
   }
-};
+}
 
 export { maskSensitiveData };

package/src/services/range.ts

@@ -0,0 +1,15 @@
+const normalizeRange = (
+  range: number | [number, number],
+  limit: number
+): [number, number] => {
+  if (Array.isArray(range)) return range;
+
+  if (range >= 0) return [0, range];
+
+  return [limit + 1 - Math.abs(range), limit];
+};
+
+const within = (range: [number, number], value: number): boolean =>
+  value >= range[0] && value <= range[1];
+
+export { normalizeRange, within };

package/src/services/truncateLargeFields.ts

@@ -1,39 +1,5 @@
-import type { TruncateLargeFieldsFunction } from "@arkyn/types";
-
-/**
- * Truncates large string fields in a JSON string to a specified maximum length.
- *
- * This function parses a JSON string, traverses its structure recursively, and truncates
- * any string fields that exceed the specified maximum length. If a string field is truncated,
- * it is replaced with a message indicating the original length of the field.
- *
- * @param jsonString - The JSON string to process.
- * @param maxLength - The maximum allowed length for string fields. Defaults to 1000.
- * @returns A JSON string with large string fields truncated.
- *
- * @throws {Error} Throws an error if the input is not a valid JSON string.
- *
- * @example
- * ```typescript
- * const json = JSON.stringify({
- *   name: "John",
- *   description: "A very long description that exceeds the maximum length...",
- *   nested: {
- *     details: "Another long string that needs truncation."
- *   }
- * });
- *
- * const result = truncateLargeFields(json, 50);
- * console.log(result);
- * // Output: '{"name":"John","description":"To large information: field as 57 characters","nested":{"details":"To large information: field as 43 characters"}}'
- * ```
- */
-
-const truncateLargeFields: TruncateLargeFieldsFunction = (
-  jsonString,
-  maxLength = 1000
-) => {
-  function truncateValue(value: any): any {
+function truncateLargeFields(jsonString: string, maxLength = 1000): string {
+  function truncateValue(key: string, value: any): any {
     if (typeof value === "string" && value.length > maxLength) {
       return `To large information: field as ${value.length} characters`;
     }
@@ -42,16 +8,16 @@ const truncateLargeFields: TruncateLargeFieldsFunction = (
 
   function recursiveTruncate(obj: any): any {
     if (Array.isArray(obj)) {
-      return obj.map((item) => recursiveTruncate(item)); // Corrigido para processar elementos do array
+      return obj.map(recursiveTruncate);
     } else if (obj !== null && typeof obj === "object") {
       return Object.fromEntries(
         Object.entries(obj).map(([key, value]) => [
           key,
-          recursiveTruncate(value), // Corrigido para aplicar recursão corretamente
+          truncateValue(key, recursiveTruncate(value)),
         ])
       );
     }
-    return truncateValue(obj); // Corrigido para truncar valores diretamente
+    return obj;
   }
 
   try {
@@ -61,6 +27,6 @@ const truncateLargeFields: TruncateLargeFieldsFunction = (
   } catch (error) {
     throw new Error("Invalid JSON string");
   }
-};
+}
 
 export { truncateLargeFields };

package/src/validations/regex.ts

@@ -0,0 +1,41 @@
+const CEP = /^(\d{8}|\d{2}\.?\d{3}\-\d{3})$/;
+
+const CNPJ = /(^\d{2}\.\d{3}\.\d{3}\/\d{4}\-\d{2}$)/;
+
+const CPF = /(^\d{3}\.\d{3}\.\d{3}\-\d{2}$)/;
+
+const DATE = /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[012])\/\d{4}$/;
+
+const DATEHOUR =
+  /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[012])\/\d{4}\s(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])$/;
+
+const HOUR = /^(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])$/;
+
+const PASSWORD =
+  /(?=^.{8,}$)((?=.*\w)(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[|!"$%&\/\(\)\?\^\'\\\+\-\*]))^.*/;
+
+const PHONE = /([0-9]{2})?(\s|-)?(9?[0-9]{4})-?([0-9]{4}$)/;
+
+const RG = /(^\d{1,2}).?(\d{3}).?(\d{3})-?(\d{1}|X|x$)/;
+
+const URL =
+  /^(((https?|ftp):\/\/)?([\w\-\.])+(\.)([\w]){2,4}([\w\/+=%&_\.~?\-]*))*$/;
+
+const CPFCNPJ =
+  /^(?:(\d{3}\.\d{3}\.\d{3}-\d{2})|(\d{11})|(\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2})|(\d{14}))$/;
+
+const regex = {
+  URL,
+  HOUR,
+  RG,
+  PHONE,
+  PASSWORD,
+  DATEHOUR,
+  CPF,
+  CNPJ,
+  CEP,
+  CPFCNPJ,
+  DATE,
+};
+
+export { regex };

package/src/validations/validateCPF.ts

@@ -0,0 +1,38 @@
+function removeNonDigits(cpf: string) {
+  return cpf.replace(/\D/g, "");
+}
+
+function isInvalidLength(cpf: string) {
+  const CPF_LENGTH = 11;
+  return cpf.length !== CPF_LENGTH;
+}
+
+function hasAllDigitsEqual(cpf: string) {
+  const [firstCpfDigit] = cpf;
+  return [...cpf].every((digit) => digit === firstCpfDigit);
+}
+
+function calculateDigit(cpf: string, factor: number) {
+  let total = 0;
+  for (const digit of cpf) {
+    if (factor > 1) total += parseInt(digit) * factor--;
+  }
+  const rest = total % 11;
+  return rest < 2 ? 0 : 11 - rest;
+}
+
+function extractDigit(cpf: string) {
+  return cpf.slice(9);
+}
+
+function validateCPF(rawCpf: string) {
+  if (!rawCpf) return false;
+  const cpf = removeNonDigits(rawCpf);
+  if (isInvalidLength(cpf)) return false;
+  if (hasAllDigitsEqual(cpf)) return false;
+  const digit1 = calculateDigit(cpf, 10);
+  const digit2 = calculateDigit(cpf, 11);
+  return extractDigit(cpf) === `${digit1}${digit2}`;
+}
+
+export { validateCPF };

package/src/validations/validateDate.ts

@@ -1,47 +1,25 @@
-import type { ValidateDateFunction } from "@arkyn/types";
+type Format = "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
 
-/**
- * Validates a date string based on the provided format and configuration.
- *
- * @param date - 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)
- * ```
- */
+type Config = {
+  minYear?: number;
+  maxYear?: number;
+};
 
-const validateDate: ValidateDateFunction = (date, config) => {
+function validateDate(date: string, format: Format, config?: Config): boolean {
   let day: string, month: string, year: string;
 
-  const inputFormat = config?.inputFormat || "DD/MM/YYYY";
-  const minYear = config?.minYear || 1900;
+  const minYear = config?.minYear || 0;
   const maxYear = config?.maxYear || 3000;
 
-  if (inputFormat === "DD/MM/YYYY") {
+  if (format === "DD/MM/YYYY") {
     const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
     if (!dateRegex.test(date)) return false;
     [, day, month, year] = date.match(dateRegex) || [];
-  } else if (inputFormat === "MM-DD-YYYY") {
+  } else if (format === "MM-DD-YYYY") {
     const dateRegex = /^(\d{2})-(\d{2})-(\d{4})$/;
     if (!dateRegex.test(date)) return false;
     [, month, day, year] = date.match(dateRegex) || [];
-  } else if (inputFormat === "YYYY-MM-DD") {
+  } else if (format === "YYYY-MM-DD") {
     const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
     if (!dateRegex.test(date)) return false;
     [, year, month, day] = date.match(dateRegex) || [];
@@ -72,6 +50,6 @@ const validateDate: ValidateDateFunction = (date, config) => {
     new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
 
   return isValidDate;
-};
+}
 
 export { validateDate };

package/src/validations/validatePhone.ts

@@ -1,33 +1,6 @@
 import { countries } from "@arkyn/templates";
-import type { ValidatePhoneFunction } from "@arkyn/types";
 
-/**
- * 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 phone - 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: ValidatePhoneFunction = (phone) => {
+function validatePhone(phone: string): boolean {
   for (const country of countries) {
     const countryCode = country.code;
     const prefix = country.prefix ? `-${country.prefix}` : "";
@@ -44,6 +17,6 @@ const validatePhone: ValidatePhoneFunction = (phone) => {
   }
 
   return false;
-};
+}
 
 export { validatePhone };

package/tsconfig.json

@@ -15,6 +15,6 @@
     "types": ["bun-types"],
     "verbatimModuleSyntax": true
   },
-  "exclude": ["dist", "node_modules", "**/__test__"],
+  "exclude": ["dist", "node_modules"],
   "include": ["src/**/*.ts"]
 }

package/dist/formats/formatDate.d.ts

@@ -1,43 +0,0 @@
-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

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

@@ -1,77 +0,0 @@
-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/formatToCnpj.d.ts

@@ -1,30 +0,0 @@
-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

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

@@ -1,35 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

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