@arkyn/shared 1.4.57 → 1.5.1

package/src/generators/__test__/generateId.spec.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { generateId } from "../generateId";
+
+describe("generateId", () => {
+  it("should generate a valid UUID v4 as text", () => {
+    const id = generateId("text", "v4");
+    expect(typeof id).toBe("string");
+    expect(id).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+    );
+  });
+
+  it("should generate a valid UUID v4 as binary", () => {
+    const id = generateId("binary", "v4");
+    expect(id).toBeInstanceOf(Uint8Array);
+    expect(id.length).toBe(16); // UUIDs in binary format are 16 bytes
+  });
+
+  it("should generate a valid UUID v7 as text", () => {
+    const id = generateId("text", "v7");
+    expect(typeof id).toBe("string");
+    expect(id).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+    );
+  });
+
+  it("should generate a valid UUID v7 as binary", () => {
+    const id = generateId("binary", "v7");
+    expect(id).toBeInstanceOf(Uint8Array);
+    expect(id.length).toBe(16); // UUIDs in binary format are 16 bytes
+  });
+
+  it("should throw an error for invalid type", () => {
+    expect(() => generateId("invalid" as any, "v4")).toThrow(
+      "Invalid type or format"
+    );
+  });
+
+  it("should throw an error for invalid format", () => {
+    expect(() => generateId("text", "v8" as any)).toThrow(
+      "Invalid type or format"
+    );
+  });
+});

package/src/generators/__test__/generateSlug.spec.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { generateSlug } from "../generateSlug";
+
+describe("generateSlug", () => {
+  it("should convert a string to a URL-friendly slug", () => {
+    expect(generateSlug("Hello World")).toBe("hello-world");
+    expect(generateSlug("This is a Test")).toBe("this-is-a-test");
+  });
+
+  it("should remove diacritical marks (accents)", () => {
+    expect(generateSlug("Olá Mundo")).toBe("ola-mundo");
+    expect(generateSlug("Crème brûlée")).toBe("creme-brulee");
+  });
+
+  it("should remove non-alphanumeric characters except spaces and hyphens", () => {
+    expect(generateSlug("Hello, World!")).toBe("hello-world");
+    expect(generateSlug("C# Programming")).toBe("c-programming");
+  });
+
+  it("should collapse multiple spaces into a single hyphen", () => {
+    expect(generateSlug("Hello     World")).toBe("hello-world");
+  });
+
+  it("should collapse multiple consecutive hyphens into a single hyphen", () => {
+    expect(generateSlug("Hello--World")).toBe("hello-world");
+    expect(generateSlug("Hello---World")).toBe("hello-world");
+  });
+
+  it("should trim leading and trailing hyphens", () => {
+    expect(generateSlug("-Hello World-")).toBe("hello-world");
+    expect(generateSlug("--Hello World--")).toBe("hello-world");
+  });
+
+  it("should handle empty strings", () => {
+    expect(generateSlug("")).toBe("");
+  });
+
+  it("should handle strings with only special characters", () => {
+    expect(generateSlug("!@#$%^&*()")).toBe("");
+    expect(generateSlug("---")).toBe("");
+  });
+
+  it("should handle strings with numbers", () => {
+    expect(generateSlug("Version 2.0")).toBe("version-20");
+    expect(generateSlug("123 Testing")).toBe("123-testing");
+  });
+});

package/src/index.ts

@@ -1,3 +1,4 @@
+// formats
 export { formatDate } from "./formats/formatDate";
 export { formatJsonObject } from "./formats/formatJsonObject";
 export { formatJsonString } from "./formats/formatJsonString";
@@ -10,17 +11,21 @@ export { formatToEllipsis } from "./formats/formatToEllipsis";
 export { formatToHiddenDigits } from "./formats/formatToHiddenDigits";
 export { formatToPhone } from "./formats/formatToPhone";
 
+// generators
 export { generateColorByString } from "./generators/generateColorByString";
 export { generateId } from "./generators/generateId";
 export { generateSlug } from "./generators/generateSlug";
 
-export { regex } from "./regex";
-
+// services
 export { calculateCardInstallment } from "./services/calculateCardInstallment";
 export { maskSensitiveData } from "./services/maskSensitiveData";
 export { removeNonNumeric } from "./services/removeNonNumeric";
 export { truncateLargeFields } from "./services/truncateLargeFields";
 
+// utils
+export { validateCep } from "./validations/validateCep";
+export { validateCnpj } from "./validations/validateCnpj";
 export { validateCpf } from "./validations/validateCpf";
 export { validateDate } from "./validations/validateDate";
 export { validatePhone } from "./validations/validatePhone";
+export { validateRg } from "./validations/validateRg";

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

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { calculateCardInstallment } from "../calculateCardInstallment";
+
+describe("calculateCardInstallment", () => {
+  it("should calculate the total and installment price with default fees", () => {
+    const result = calculateCardInstallment({
+      cashPrice: 1000,
+      numberInstallments: 12,
+    });
+
+    expect(result).toEqual({
+      totalPrice: 1241.08,
+      installmentPrice: 103.42,
+    });
+  });
+
+  it("should calculate the total and installment price with custom fees", () => {
+    const result = calculateCardInstallment({
+      cashPrice: 1000,
+      numberInstallments: 12,
+      fees: 0.02,
+    });
+
+    expect(result).toEqual({
+      totalPrice: 1134.72,
+      installmentPrice: 94.56,
+    });
+  });
+
+  it("should calculate correctly for a single installment (no interest)", () => {
+    const result = calculateCardInstallment({
+      cashPrice: 1000,
+      numberInstallments: 1,
+      fees: 0,
+    });
+
+    expect(result).toEqual({
+      totalPrice: 1000,
+      installmentPrice: 1000,
+    });
+  });
+
+  it("should calculate correctly for zero fees", () => {
+    const result = calculateCardInstallment({
+      cashPrice: 500,
+      numberInstallments: 5,
+      fees: 0,
+    });
+
+    expect(result).toEqual({
+      totalPrice: 500,
+      installmentPrice: 100,
+    });
+  });
+
+  it("should handle edge case with zero installments", () => {
+    expect(() =>
+      calculateCardInstallment({
+        cashPrice: 1000,
+        numberInstallments: 0,
+      })
+    ).toThrow("Number of installments must be greater than 0");
+  });
+
+  it("should handle edge case with negative fees", () => {
+    expect(() =>
+      calculateCardInstallment({
+        cashPrice: 1000,
+        numberInstallments: 12,
+        fees: -0.01,
+      })
+    ).toThrow("Fees must be greater than or equal to 0");
+  });
+
+  it("should handle large numbers for cash price and installments", () => {
+    const result = calculateCardInstallment({
+      cashPrice: 1000000,
+      numberInstallments: 24,
+      fees: 0.01,
+    });
+
+    expect(result).toEqual({
+      totalPrice: 1129763.33,
+      installmentPrice: 47073.47,
+    });
+  });
+});

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

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { maskSensitiveData } from "../maskSensitiveData";
+
+describe("maskSensitiveData", () => {
+  it("should mask sensitive keys in a flat JSON object", () => {
+    const jsonString = JSON.stringify({
+      username: "user123",
+      password: "secret",
+      email: "user@example.com",
+    });
+
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe(
+      '{"username":"user123","password":"****","email":"user@example.com"}'
+    );
+  });
+
+  it("should mask sensitive keys in nested objects", () => {
+    const jsonString = JSON.stringify({
+      profile: {
+        username: "user123",
+        creditCard: "1234-5678-9012-3456",
+      },
+    });
+
+    const result = maskSensitiveData(jsonString, ["creditCard"]);
+    expect(result).toBe(
+      '{"profile":{"username":"user123","creditCard":"****"}}'
+    );
+  });
+
+  it("should mask sensitive keys in arrays", () => {
+    const jsonString = JSON.stringify({
+      users: [
+        { username: "user1", password: "pass1" },
+        { username: "user2", password: "pass2" },
+      ],
+    });
+
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe(
+      '{"users":[{"username":"user1","password":"****"},{"username":"user2","password":"****"}]}'
+    );
+  });
+
+  it("should handle non-JSON strings gracefully", () => {
+    const invalidJson = "not a json string";
+    const result = maskSensitiveData(invalidJson, ["password"]);
+    expect(result).toBe("not a json string");
+  });
+
+  it("should handle empty JSON objects", () => {
+    const jsonString = JSON.stringify({});
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe("{}");
+  });
+
+  it("should handle empty arrays", () => {
+    const jsonString = JSON.stringify([]);
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe("[]");
+  });
+
+  it("should use default sensitive keys if none are provided", () => {
+    const jsonString = JSON.stringify({
+      username: "user123",
+      password: "secret",
+      confirmPassword: "secret",
+      creditCard: "1234-5678-9012-3456",
+    });
+
+    const result = maskSensitiveData(jsonString);
+    expect(result).toBe(
+      '{"username":"user123","password":"****","confirmPassword":"****","creditCard":"****"}'
+    );
+  });
+
+  it("should not mask keys that are not in the sensitive keys list", () => {
+    const jsonString = JSON.stringify({
+      username: "user123",
+      email: "user@example.com",
+    });
+
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe('{"username":"user123","email":"user@example.com"}');
+  });
+
+  it("should handle deeply nested objects", () => {
+    const jsonString = JSON.stringify({
+      level1: {
+        level2: {
+          level3: {
+            password: "secret",
+          },
+        },
+      },
+    });
+
+    const result = maskSensitiveData(jsonString, ["password"]);
+    expect(result).toBe('{"level1":{"level2":{"level3":{"password":"****"}}}}');
+  });
+});

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

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { removeCurrencySymbols } from "../removeCurrencySymbols";
+
+describe("removeCurrencySymbols", () => {
+  it("should remove common currency symbols from the string", () => {
+    expect(removeCurrencySymbols("R$13,45")).toBe("13,45");
+    expect(removeCurrencySymbols("$123.45")).toBe("123.45");
+    expect(removeCurrencySymbols("€99.99")).toBe("99.99");
+    expect(removeCurrencySymbols("¥1,000")).toBe("1,000");
+  });
+
+  it("should handle strings without currency symbols", () => {
+    expect(removeCurrencySymbols("123.45")).toBe("123.45");
+    expect(removeCurrencySymbols("1,000")).toBe("1,000");
+  });
+
+  it("should handle strings with multiple currency symbols", () => {
+    expect(removeCurrencySymbols("R$ $123.45")).toBe("123.45");
+    expect(removeCurrencySymbols("€¥99,99")).toBe("99,99");
+  });
+
+  it("should handle strings with leading and trailing whitespace", () => {
+    expect(removeCurrencySymbols("  $123.45  ")).toBe("123.45");
+    expect(removeCurrencySymbols("\t€99.99\n")).toBe("99.99");
+  });
+
+  it("should return an empty string if the input is only currency symbols", () => {
+    expect(removeCurrencySymbols("R$")).toBe("");
+    expect(removeCurrencySymbols("$")).toBe("");
+    expect(removeCurrencySymbols("€")).toBe("");
+  });
+
+  it("should handle an empty string input", () => {
+    expect(removeCurrencySymbols("")).toBe("");
+  });
+
+  it("should handle strings with special characters but no currency symbols", () => {
+    expect(removeCurrencySymbols("123-45")).toBe("123-45");
+    expect(removeCurrencySymbols("1,000.00")).toBe("1,000.00");
+  });
+});

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/validations/__test__/validateCep.spec.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { validateCep } from "../validateCep";
+
+describe("validateCep", () => {
+  it("should return true for a valid CEP with formatting", () => {
+    const validCep = "12345-678";
+    expect(validateCep(validCep)).toBe(true);
+  });
+
+  it("should return true for a valid CEP without formatting", () => {
+    const validCep = "12345678";
+    expect(validateCep(validCep)).toBe(true);
+  });
+
+  it("should return false for a CEP with letters", () => {
+    const invalidCep = "ABCDE-123";
+    expect(validateCep(invalidCep)).toBe(false);
+  });
+
+  it("should return false for a CEP with special characters", () => {
+    const invalidCep = "12345@678";
+    expect(validateCep(invalidCep)).toBe(false);
+  });
+
+  it("should return false for a CEP with invalid length", () => {
+    const shortCep = "12345";
+    const longCep = "123456789";
+    expect(validateCep(shortCep)).toBe(false);
+    expect(validateCep(longCep)).toBe(false);
+  });
+
+  it("should return false for an empty CEP", () => {
+    expect(validateCep("")).toBe(false);
+  });
+
+  it("should return false for a null or undefined CEP", () => {
+    expect(validateCep(null as unknown as string)).toBe(false);
+    expect(validateCep(undefined as unknown as string)).toBe(false);
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { validateCnpj } from "../validateCnpj";
+
+describe("validateCnpj", () => {
+  it("should return true for a valid CNPJ", () => {
+    const validCnpj = "11.444.777/0001-61";
+    expect(validateCnpj(validCnpj)).toBe(true);
+  });
+
+  it("should return false for an invalid CNPJ", () => {
+    const invalidCnpj = "12.345.679/0001-95";
+    expect(validateCnpj(invalidCnpj)).toBe(false);
+  });
+
+  it("should return false for a CNPJ with all digits equal", () => {
+    const invalidCnpj = "11111111111111";
+    expect(validateCnpj(invalidCnpj)).toBe(false);
+  });
+
+  it("should return false for a CNPJ with invalid length", () => {
+    const shortCnpj = "12345678";
+    const longCnpj = "123456789012345";
+    expect(validateCnpj(shortCnpj)).toBe(false);
+    expect(validateCnpj(longCnpj)).toBe(false);
+  });
+
+  it("should return false for an empty CNPJ", () => {
+    expect(validateCnpj("")).toBe(false);
+  });
+
+  it("should return false for a null or undefined CNPJ", () => {
+    expect(validateCnpj(null as unknown as string)).toBe(false);
+    expect(validateCnpj(undefined as unknown as string)).toBe(false);
+  });
+
+  it("should handle CNPJs with non-digit characters", () => {
+    const validCnpj = "11.444.777/0001-61";
+    const formattedCnpj = "11444777000161";
+    expect(validateCnpj(validCnpj)).toBe(true);
+    expect(validateCnpj(formattedCnpj)).toBe(true);
+  });
+});

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);
+  });
+});