@arkyn/shared 1.5.0 → 1.5.2

package/dist/validations/validateCnpj.js

@@ -0,0 +1,52 @@
+import { removeNonNumeric } from "../services/removeNonNumeric";
+function isInvalidLength(cnpj) {
+    const CNPJ_LENGTH = 14;
+    return cnpj.length !== CNPJ_LENGTH;
+}
+function hasAllDigitsEqual(cnpj) {
+    const [firstDigit] = cnpj;
+    return [...cnpj].every((digit) => digit === firstDigit);
+}
+function calculateDigit(cnpj, multipliers) {
+    let total = 0;
+    for (let i = 0; i < multipliers.length; i++) {
+        total += parseInt(cnpj[i]) * multipliers[i];
+    }
+    const rest = total % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+function extractDigit(cnpj) {
+    return cnpj.slice(12);
+}
+/**
+ * Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number.
+ *
+ * This function performs:
+ * - Sanitization (removes non-digit characters).
+ * - Length check (must be 14 digits).
+ * - Repeating digits check (invalid if all digits are the same).
+ * - Verifies the two check digits with the proper weights.
+ *
+ * @param rawCnpj - CNPJ string, possibly formatted.
+ * @returns `true` if valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validateCnpj("12.345.678/0001-95"); // false
+ * validateCnpj("11.444.777/0001-61"); // true
+ * ```
+ */
+const validateCnpj = (rawCnpj) => {
+    if (!rawCnpj)
+        return false;
+    const cnpj = removeNonNumeric(rawCnpj);
+    if (isInvalidLength(cnpj))
+        return false;
+    if (hasAllDigitsEqual(cnpj))
+        return false;
+    const base = cnpj.slice(0, 12);
+    const digit1 = calculateDigit(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
+    const digit2 = calculateDigit(base + digit1, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
+    return extractDigit(cnpj) === `${digit1}${digit2}`;
+};
+export { validateCnpj };

package/dist/validations/validateCpf.d.ts

@@ -0,0 +1,24 @@
+import type { ValidateCpfFunction } from "@arkyn/types";
+/**
+ * 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
+ * ```
+ */
+declare const validateCpf: ValidateCpfFunction;
+export { validateCpf };
+//# sourceMappingURL=validateCpf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AA0BxD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAWlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -0,0 +1,54 @@
+import { removeNonNumeric } from "../services/removeNonNumeric";
+function isInvalidLength(cpf) {
+    const CPF_LENGTH = 11;
+    return cpf.length !== CPF_LENGTH;
+}
+function hasAllDigitsEqual(cpf) {
+    const [firstCpfDigit] = cpf;
+    return [...cpf].every((digit) => digit === firstCpfDigit);
+}
+function calculateDigit(cpf, factor) {
+    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) {
+    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 = (rawCpf) => {
+    if (!rawCpf)
+        return false;
+    const cpf = removeNonNumeric(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/dist/validations/validateDate.d.ts

@@ -1,8 +1,29 @@
-type Format = "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
-type Config = {
-    minYear?: number;
-    maxYear?: number;
-};
-declare function validateDate(date: string, format: Format, config?: Config): boolean;
+import type { ValidateDateFunction } from "@arkyn/types";
+/**
+ * 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 +1 @@
-{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;AAEzD,KAAK,MAAM,GAAG;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,iBAAS,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CA6C5E;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateDate.js

@@ -1,24 +1,50 @@
-function validateDate(date, format, config) {
+/**
+ * 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 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))
+        if (!dateRegex.test(rawDate))
             return false;
-        [, day, month, year] = date.match(dateRegex) || [];
+        [, day, month, year] = rawDate.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))
+        if (!dateRegex.test(rawDate))
             return false;
-        [, month, day, year] = date.match(dateRegex) || [];
+        [, month, day, year] = rawDate.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))
+        if (!dateRegex.test(rawDate))
             return false;
-        [, year, month, day] = date.match(dateRegex) || [];
+        [, year, month, day] = rawDate.match(dateRegex) || [];
     }
     else {
         throw new Error("Invalid date format");
@@ -43,5 +69,5 @@ function validateDate(date, format, config) {
         return false;
     const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
     return isValidDate;
-}
+};
 export { validateDate };

package/dist/validations/validatePassword.d.ts

@@ -0,0 +1,21 @@
+import type { ValidatePasswordFunction } from "@arkyn/types";
+/**
+ * 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

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

package/dist/validations/validatePassword.js

@@ -0,0 +1,34 @@
+/**
+ * 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,3 +1,29 @@
-declare function validatePhone(phone: string): boolean;
+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 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 +1 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAiB7C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -1,19 +1,44 @@
 import { countries } from "@arkyn/templates";
-function validatePhone(phone) {
+/**
+ * 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(phone))
+            if (brazilRegex.test(rawPhone))
                 return true;
             continue;
         }
         const regex = new RegExp(`^\\${countryCode}${prefix} \\d{${digitCount}}$`);
-        if (regex.test(phone))
+        if (regex.test(rawPhone))
             return true;
     }
     return false;
-}
+};
 export { validatePhone };

package/dist/validations/validateRg.d.ts

@@ -0,0 +1,22 @@
+import type { ValidateRgFunction } from "@arkyn/types";
+/**
+ * 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

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

package/dist/validations/validateRg.js

@@ -0,0 +1,31 @@
+/**
+ * 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/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@arkyn/shared",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
   "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "author": "Arkyn | Lucas Gonçalves",
+  "description": "Shared utilities and types for projects.",
   "scripts": {
     "clean": "rm -rf dist",
     "build": "bun run clean && bunx tsc --project tsconfig.json",
+    "test": "vitest --config vitest.config.ts",
     "typecheck": "bunx tsc --project tsconfig.json --noEmit"
   },
   "dependencies": {
@@ -16,6 +20,7 @@
   "devDependencies": {
     "@types/uuid": "^10.0.0",
     "bun-types": "latest",
-    "typescript": "^5.8.2"
+    "vitest": "^3.1.1",
+    "typescript": "^5.8.3"
   }
 }

package/src/formats/__test__/formatDate.spec.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { formatDate } from "../formatDate";
+
+describe("formatDate", () => {
+  it("should format a Brazilian date to ISO format", () => {
+    const result = formatDate(
+      "25/12/2023",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2023-12-25");
+  });
+
+  it("should format an ISO date to Brazilian format", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "00:00:00",
+      "isoDate",
+      "DD/MM/YYYY"
+    );
+    expect(result).toBe("25/12/2023");
+  });
+
+  it("should format a date with time components", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "14:30:00",
+      "isoDate",
+      "YYYY-MM-DD hh:mm:ss"
+    );
+    expect(result).toBe("2023-12-25 14:30:00");
+  });
+
+  it("should apply timezone adjustment when formatting", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "14:30:00",
+      "isoDate",
+      "YYYY-MM-DD hh:mm:ss",
+      -3
+    );
+    expect(result).toBe("2023-12-25 11:30:00");
+  });
+
+  it("should handle single-digit days and months in Brazilian format", () => {
+    const result = formatDate(
+      "5/1/2023",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2023-01-05");
+  });
+
+  it("should handle single-digit days and months in ISO format", () => {
+    const result = formatDate("2023-1-5", "00:00:00", "isoDate", "DD/MM/YYYY");
+    expect(result).toBe("05/01/2023");
+  });
+
+  it("should handle leap years correctly", () => {
+    const result = formatDate(
+      "29/02/2024",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2024-02-29");
+  });
+
+  it("should throw an error for invalid input format", () => {
+    expect(() =>
+      formatDate("25/12/2023", "00:00:00", "invalidFormat" as any, "YYYY-MM-DD")
+    ).toThrow("Invalid input format");
+  });
+
+  it("should throw an error for invalid date string", () => {
+    expect(() =>
+      formatDate("invalid-date", "00:00:00", "brazilianDate", "YYYY-MM-DD")
+    ).toThrow("Invalid date");
+  });
+
+  it("should throw an error for invalid time string", () => {
+    expect(() =>
+      formatDate("25/12/2023", "invalid-time", "brazilianDate", "YYYY-MM-DD")
+    ).toThrow("Invalid date");
+  });
+});

package/src/formats/__test__/formatJsonObject.spec.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { formatJsonObject } from "../formatJsonObject";
+
+describe("formatJsonObject", () => {
+  it("should format a simple JSON object", () => {
+    const obj = { name: "John", age: 30 };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "age": 30
+}`);
+  });
+
+  it("should format a nested JSON object", () => {
+    const obj = { name: "John", details: { age: 30, city: "New York" } };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "details": {
+    "age": 30,
+    "city": "New York"
+  }
+}`);
+  });
+
+  it("should format a JSON array", () => {
+    const obj = ["apple", "banana", "cherry"];
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`[
+  "apple",
+  "banana",
+  "cherry"
+]`);
+  });
+
+  it("should format a nested JSON array", () => {
+    const obj = { fruits: ["apple", "banana", "cherry"] };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "fruits": [
+    "apple",
+    "banana",
+    "cherry"
+  ]
+}`);
+  });
+
+  it("should format a primitive value", () => {
+    const result = formatJsonObject(42, 0);
+    expect(result).toBe("42");
+  });
+
+  it("should format a string value", () => {
+    const result = formatJsonObject("hello", 0);
+    expect(result).toBe('"hello"');
+  });
+
+  it("should format a JSON string", () => {
+    const jsonString = '{"name":"John","age":30}';
+    const result = formatJsonObject(jsonString, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "age": 30
+}`);
+  });
+
+  it("should handle invalid JSON strings as plain strings", () => {
+    const invalidJson = "{name:John}";
+    const result = formatJsonObject(invalidJson, 0);
+    expect(result).toBe('"{name:John}"');
+  });
+
+  it("should handle null values", () => {
+    const result = formatJsonObject(null, 0);
+    expect(result).toBe("null");
+  });
+
+  it("should handle empty objects", () => {
+    const result = formatJsonObject({}, 0);
+    expect(result).toBe(`{}`);
+  });
+
+  it("should handle empty arrays", () => {
+    const result = formatJsonObject([], 0);
+    expect(result).toBe(`[]`);
+  });
+});