@arkyn/shared 1.4.52 → 2.0.1-beta.0

package/src/services/__test__/removeNonNumeric.spec.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { removeNonNumeric } from "../removeNonNumeric";
+
+describe("removeNonNumeric", () => {
+  it("should remove all non-numeric characters from a string", () => {
+    expect(removeNonNumeric("abc123def456")).toBe("123456");
+    expect(removeNonNumeric("!@#123$%^456&*()")).toBe("123456");
+    expect(removeNonNumeric("a1b2c3")).toBe("123");
+  });
+
+  it("should return an empty string if there are no numeric characters", () => {
+    expect(removeNonNumeric("abcdef")).toBe("");
+    expect(removeNonNumeric("!@#$%^&*()")).toBe("");
+  });
+
+  it("should return the same string if it contains only numeric characters", () => {
+    expect(removeNonNumeric("123456")).toBe("123456");
+    expect(removeNonNumeric("000123")).toBe("000123");
+  });
+
+  it("should handle an empty string input", () => {
+    expect(removeNonNumeric("")).toBe("");
+  });
+
+  it("should handle strings with spaces and remove them", () => {
+    expect(removeNonNumeric("123 456 789")).toBe("123456789");
+    expect(removeNonNumeric(" 1 2 3 ")).toBe("123");
+  });
+
+  it("should handle strings with special characters and preserve only numbers", () => {
+    expect(removeNonNumeric("12-34.56/78")).toBe("12345678");
+  });
+});

package/src/services/__test__/truncateLargeFields.spec.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { truncateLargeFields } from "../truncateLargeFields";
+
+describe("truncateLargeFields", () => {
+  it("should truncate string fields exceeding the maxLength", () => {
+    const json = JSON.stringify({
+      name: "John",
+      description: "A very long description that exceeds the maximum length...",
+    });
+
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe(
+      '{"name":"John","description":"To large information: field as 58 characters"}'
+    );
+  });
+
+  it("should handle nested objects and truncate large string fields", () => {
+    const json = JSON.stringify({
+      nested: {
+        details: "Another long string that needs truncation.",
+      },
+    });
+
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe(
+      '{"nested":{"details":"To large information: field as 42 characters"}}'
+    );
+  });
+
+  it("should handle arrays and truncate large string fields within them", () => {
+    const json = JSON.stringify({
+      items: ["short", "A very long string in an array that exceeds the limit"],
+    });
+
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe(
+      '{"items":["short","To large information: field as 53 characters"]}'
+    );
+  });
+
+  it("should not modify fields that are within the maxLength", () => {
+    const json = JSON.stringify({
+      name: "John",
+      description: "Short description",
+    });
+
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe('{"name":"John","description":"Short description"}');
+  });
+
+  it("should throw an error for invalid JSON strings", () => {
+    const invalidJson = "{ name: 'John' }"; // Invalid JSON
+    expect(() => truncateLargeFields(invalidJson, 20)).toThrow(
+      "Invalid JSON string"
+    );
+  });
+
+  it("should handle empty JSON objects", () => {
+    const json = JSON.stringify({});
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe("{}");
+  });
+
+  it("should handle empty arrays", () => {
+    const json = JSON.stringify([]);
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe("[]");
+  });
+
+  it("should handle non-string fields without modification", () => {
+    const json = JSON.stringify({
+      number: 123,
+      boolean: true,
+      nullValue: null,
+    });
+
+    const result = truncateLargeFields(json, 20);
+    expect(result).toBe('{"number":123,"boolean":true,"nullValue":null}');
+  });
+
+  it("should use the default maxLength of 1000 if not provided", () => {
+    const longString = "a".repeat(1500);
+    const json = JSON.stringify({ longField: longString });
+    const result = truncateLargeFields(json);
+
+    expect(result).toBe(
+      `{"longField":"To large information: field as 1500 characters"}`
+    );
+  });
+});

package/src/services/calculateCardInstallment.ts

@@ -1,21 +1,66 @@
-import type { CalculateCardInstallmentProps } from "@arkyn/types";
+import type { CalculateCardInstallmentFunction } from "@arkyn/types";
 
-function calculateCardInstallment(args: CalculateCardInstallmentProps) {
-  const { cash_price, number_installments, fees = 0.0349 } = args;
+/**
+ * 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 }
+ * ```
+ */
 
-  let installment_price = 0;
-  let total_price = 0;
+const calculateCardInstallment: CalculateCardInstallmentFunction = (props) => {
+  const { cashPrice, numberInstallments, fees = 0.0349 } = props;
 
-  let numerator = Math.pow(1 + fees, number_installments) * fees;
-  let denominator = Math.pow(1 + fees, number_installments) - 1;
+  if (fees === 0 || numberInstallments === 1) {
+    return {
+      totalPrice: cashPrice,
+      installmentPrice: cashPrice / numberInstallments,
+    };
+  }
 
-  installment_price = cash_price * (numerator / denominator);
-  total_price = number_installments * installment_price;
+  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;
 
   return {
-    total_price: +total_price.toFixed(2),
-    installment_price: +installment_price.toFixed(2),
+    totalPrice: +totalPrice.toFixed(2),
+    installmentPrice: +installmentPrice.toFixed(2),
   };
-}
+};
 
 export { calculateCardInstallment };

package/src/services/maskSensitiveData.ts

@@ -1,7 +1,32 @@
-function maskSensitiveData(
-  jsonString: string,
+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,
   sensitiveKeys = ["password", "confirmPassword", "creditCard"]
-): string {
+) => {
   function maskValue(key: string, value: any): any {
     if (sensitiveKeys.includes(key)) return "****";
     return value;
@@ -35,6 +60,6 @@ function maskSensitiveData(
   } catch (error) {
     return jsonString;
   }
-}
+};
 
 export { maskSensitiveData };

package/src/services/removeCurrencySymbols.ts

@@ -0,0 +1,25 @@
+/**
+ * Removes currency symbols from a given formatted string.
+ *
+ * This function takes a string that may contain currency symbols
+ * and removes them using a regular expression. The resulting string
+ * is also trimmed of any leading or trailing whitespace.
+ *
+ * @param formattedValue - The input string containing currency symbols.
+ * @returns A string with all currency symbols removed and trimmed of whitespace.
+ *
+ * @example
+ * removeCurrencySymbols("R$13,45"); // "13,45"
+ * removeCurrencySymbols("$123.45"); // "123.45"
+ * removeCurrencySymbols("€99.99"); // "99.99"
+ * removeCurrencySymbols("¥1,000"); // "1,000"
+ * removeCurrencySymbols("123.45"); // "123.45" (no symbols to remove)
+ */
+
+const removeCurrencySymbols = (formattedValue: string): string => {
+  return formattedValue
+    .replace(/(?:R\$|\p{Sc}|[$€¥£])/gu, "") // Inclui "R$" e outros símbolos comuns
+    .trim();
+};
+
+export { removeCurrencySymbols };

package/src/services/removeNonNumeric.ts

@@ -0,0 +1,18 @@
+/**
+ * Removes all non-numeric characters from a given string.
+ *
+ * @param prop - The input string from which non-numeric characters will be removed.
+ * @returns A new string containing only numeric characters from the input.
+ *
+ * @example
+ * ```typescript
+ * const result = removeNonNumeric("abc123def456");
+ * console.log(result); // Output: "123456"
+ * ```
+ */
+
+function removeNonNumeric(prop: string): string {
+  return prop.replace(/[^0-9]/g, "");
+}
+
+export { removeNonNumeric };

package/src/services/truncateLargeFields.ts

@@ -1,5 +1,39 @@
-function truncateLargeFields(jsonString: string, maxLength = 1000): string {
-  function truncateValue(key: string, value: any): any {
+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 {
     if (typeof value === "string" && value.length > maxLength) {
       return `To large information: field as ${value.length} characters`;
     }
@@ -8,16 +42,16 @@ function truncateLargeFields(jsonString: string, maxLength = 1000): string {
 
   function recursiveTruncate(obj: any): any {
     if (Array.isArray(obj)) {
-      return obj.map(recursiveTruncate);
+      return obj.map((item) => recursiveTruncate(item)); // Corrigido para processar elementos do array
     } else if (obj !== null && typeof obj === "object") {
       return Object.fromEntries(
         Object.entries(obj).map(([key, value]) => [
           key,
-          truncateValue(key, recursiveTruncate(value)),
+          recursiveTruncate(value), // Corrigido para aplicar recursão corretamente
         ])
       );
     }
-    return obj;
+    return truncateValue(obj); // Corrigido para truncar valores diretamente
   }
 
   try {
@@ -27,6 +61,6 @@ function truncateLargeFields(jsonString: string, maxLength = 1000): string {
   } catch (error) {
     throw new Error("Invalid JSON string");
   }
-}
+};
 
 export { truncateLargeFields };

package/src/validations/__test__/validateCpf.spec.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { validateCpf } from "../validateCpf";
+
+describe("validateCpf", () => {
+  it("should return false for an empty CPF", () => {
+    expect(validateCpf("")).toBe(false);
+  });
+
+  it("should return false for a CPF with invalid length", () => {
+    expect(validateCpf("123.456")).toBe(false);
+    expect(validateCpf("123.456.789.123")).toBe(false);
+  });
+
+  it("should return false for a CPF with all digits equal", () => {
+    expect(validateCpf("111.111.111-11")).toBe(false);
+    expect(validateCpf("222.222.222-22")).toBe(false);
+  });
+
+  it("should return false for an invalid CPF", () => {
+    expect(validateCpf("123.456.789-19")).toBe(false);
+    expect(validateCpf("987.654.321-01")).toBe(false);
+  });
+
+  it("should return true for a valid CPF", () => {
+    expect(validateCpf("111.444.777-35")).toBe(true);
+    expect(validateCpf("935.411.347-80")).toBe(true);
+  });
+
+  it("should ignore formatting characters and validate correctly", () => {
+    expect(validateCpf("11144477735")).toBe(true);
+    expect(validateCpf("935.411.347-80")).toBe(true);
+  });
+
+  it("should return false for a CPF with non-digit characters", () => {
+    expect(validateCpf("111.444.777-3a")).toBe(false);
+    expect(validateCpf("935.411.347-8x")).toBe(false);
+  });
+});

package/src/validations/__test__/validateDate.spec.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import { validateDate } from "../validateDate";
+
+describe("validateDate", () => {
+  it("should return true for valid dates in DD/MM/YYYY format", () => {
+    expect(validateDate("31/12/2023")).toBe(true);
+    expect(validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" })).toBe(
+      true
+    ); // Leap year
+  });
+
+  it("should return false for invalid dates in DD/MM/YYYY format", () => {
+    expect(validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" })).toBe(
+      false
+    ); // April has 30 days
+    expect(validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" })).toBe(
+      false
+    ); // Not a leap year
+    expect(validateDate("32/01/2023", { inputFormat: "DD/MM/YYYY" })).toBe(
+      false
+    ); // Invalid day
+  });
+
+  it("should return true for valid dates in MM-DD-YYYY format", () => {
+    expect(validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" })).toBe(
+      true
+    );
+  });
+
+  it("should return false for invalid dates in MM-DD-YYYY format", () => {
+    expect(validateDate("04-31-2023", { inputFormat: "MM-DD-YYYY" })).toBe(
+      false
+    ); // April has 30 days
+    expect(validateDate("02-29-2023", { inputFormat: "MM-DD-YYYY" })).toBe(
+      false
+    ); // Not a leap year
+    expect(validateDate("13-01-2023", { inputFormat: "MM-DD-YYYY" })).toBe(
+      false
+    ); // Invalid month
+  });
+
+  it("should return true for valid dates in YYYY-MM-DD format", () => {
+    expect(validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD" })).toBe(
+      true
+    );
+    expect(validateDate("2024-02-29", { inputFormat: "YYYY-MM-DD" })).toBe(
+      true
+    ); // Leap year
+  });
+
+  it("should return false for invalid dates in YYYY-MM-DD format", () => {
+    expect(validateDate("2023-04-31", { inputFormat: "YYYY-MM-DD" })).toBe(
+      false
+    ); // April has 30 days
+    expect(validateDate("2023-02-29", { inputFormat: "YYYY-MM-DD" })).toBe(
+      false
+    ); // Not a leap year
+    expect(validateDate("2023-13-01", { inputFormat: "YYYY-MM-DD" })).toBe(
+      false
+    ); // Invalid month
+  });
+
+  it("should respect minYear and maxYear configuration", () => {
+    expect(validateDate("01/01/1899", { minYear: 1900 })).toBe(false); // Below minYear
+    expect(validateDate("01/01/1900", { minYear: 1900 })).toBe(true); // Equal to minYear
+    expect(validateDate("31/12/3001", { maxYear: 3000 })).toBe(false); // Above maxYear
+    expect(validateDate("31/12/3000", { maxYear: 3000 })).toBe(true); // Equal to maxYear
+  });
+
+  it("should throw an error for unsupported date formats", () => {
+    expect(() =>
+      validateDate("2023.12.31", { inputFormat: "YYYY.MM.DD" } as any)
+    ).toThrow("Invalid date format");
+  });
+
+  it("should return false for completely invalid date strings", () => {
+    expect(validateDate("invalid-date")).toBe(false);
+    expect(validateDate("12345678")).toBe(false);
+    expect(validateDate("")).toBe(false);
+  });
+});

package/src/validations/__test__/validatePhone.spec.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { validatePhone } from "../validatePhone";
+
+describe("validatePhone", () => {
+  it("should return true for valid Brazilian phone numbers", () => {
+    expect(validatePhone("+55 32912345678")).toBe(true); // Valid with 9th digit
+    expect(validatePhone("+55 3212345678")).toBe(true); // Valid without 9th digit
+  });
+
+  it("should return false for invalid Brazilian phone numbers", () => {
+    expect(validatePhone("+5532912345678")).toBe(false); // Missing space
+    expect(validatePhone("+55 123456789")).toBe(false); // Invalid format
+  });
+
+  it("should return true for valid American Samoa phone numbers", () => {
+    expect(validatePhone("+1-684 1234567")).toBe(true); // Valid format
+  });
+
+  it("should return false for invalid phone numbers", () => {
+    expect(validatePhone("+1-684 12345")).toBe(false); // Too few digits
+    expect(validatePhone("+99 1234567890")).toBe(false); // Non-existent country code
+  });
+
+  it("should return true for valid phone numbers from other countries", () => {
+    expect(validatePhone("+44 1234567890")).toBe(true); // Example for UK
+    expect(validatePhone("+91 9876543210")).toBe(true); // Example for India
+  });
+
+  it("should return false for phone numbers with incorrect prefixes", () => {
+    expect(validatePhone("+44-20 12345678")).toBe(false); // Invalid prefix for UK
+    expect(validatePhone("+91-80 12345678")).toBe(false); // Invalid prefix for India
+  });
+
+  it("should handle edge cases gracefully", () => {
+    expect(validatePhone("")).toBe(false); // Empty string
+    expect(validatePhone("+55")).toBe(false); // Only country code
+    expect(validatePhone("+55 329123456789")).toBe(false); // Too many digits
+  });
+});

package/src/validations/validateCpf.ts

@@ -0,0 +1,64 @@
+import type { ValidateCpfFunction } from "@arkyn/types";
+
+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);
+}
+
+/**
+ * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
+ *
+ * The CPF is a unique identifier assigned to Brazilian citizens and residents.
+ * This function checks if the provided CPF is valid by performing the following steps:
+ * - Removes any non-digit characters from the input.
+ * - Verifies if the CPF has the correct length (11 digits).
+ * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
+ * - Calculates the first and second verification digits using the CPF algorithm.
+ * - Compares the calculated verification digits with the ones provided in the CPF.
+ *
+ * @param rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns `true` if the CPF is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCpf("123.456.789-09"); // false
+ * validateCpf("111.444.777-35"); // true
+ * ```
+ */
+
+const validateCpf: ValidateCpfFunction = (rawCpf) => {
+  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,25 +1,47 @@
-type Format = "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
+import type { ValidateDateFunction } from "@arkyn/types";
 
-type Config = {
-  minYear?: number;
-  maxYear?: number;
-};
+/**
+ * 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)
+ * ```
+ */
 
-function validateDate(date: string, format: Format, config?: Config): boolean {
+const validateDate: ValidateDateFunction = (date, config) => {
   let day: string, month: string, year: string;
 
-  const minYear = config?.minYear || 0;
+  const inputFormat = config?.inputFormat || "DD/MM/YYYY";
+  const minYear = config?.minYear || 1900;
   const maxYear = config?.maxYear || 3000;
 
-  if (format === "DD/MM/YYYY") {
+  if (inputFormat === "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 (format === "MM-DD-YYYY") {
+  } else if (inputFormat === "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 (format === "YYYY-MM-DD") {
+  } else if (inputFormat === "YYYY-MM-DD") {
     const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
     if (!dateRegex.test(date)) return false;
     [, year, month, day] = date.match(dateRegex) || [];
@@ -50,6 +72,6 @@ function validateDate(date: string, format: Format, config?: Config): boolean {
     new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
 
   return isValidDate;
-}
+};
 
 export { validateDate };