@arkyn/shared 1.4.57 → 1.5.0

package/dist/services/maskSensitiveData.d.ts

@@ -1,26 +1,3 @@
-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":"****"}}'
- * ```
- */
-declare const maskSensitiveData: MaskSensitiveDataFunction;
+declare function maskSensitiveData(jsonString: string, sensitiveKeys?: string[]): string;
 export { maskSensitiveData };
 //# sourceMappingURL=maskSensitiveData.d.ts.map

package/dist/services/maskSensitiveData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"maskSensitiveData.d.ts","sourceRoot":"","sources":["../../src/services/maskSensitiveData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,QAAA,MAAM,iBAAiB,EAAE,yBAqCxB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"maskSensitiveData.d.ts","sourceRoot":"","sources":["../../src/services/maskSensitiveData.ts"],"names":[],"mappings":"AAAA,iBAAS,iBAAiB,CACxB,UAAU,EAAE,MAAM,EAClB,aAAa,WAAgD,GAC5D,MAAM,CAkCR;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/services/maskSensitiveData.js

@@ -1,26 +1,4 @@
-/**
- * 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 = (jsonString, sensitiveKeys = ["password", "confirmPassword", "creditCard"]) => {
+function maskSensitiveData(jsonString, sensitiveKeys = ["password", "confirmPassword", "creditCard"]) {
     function maskValue(key, value) {
         if (sensitiveKeys.includes(key))
             return "****";
@@ -56,5 +34,5 @@ const maskSensitiveData = (jsonString, sensitiveKeys = ["password", "confirmPass
     catch (error) {
         return jsonString;
     }
-};
+}
 export { maskSensitiveData };

package/dist/services/range.d.ts

@@ -0,0 +1,4 @@
+declare const normalizeRange: (range: number | [number, number], limit: number) => [number, number];
+declare const within: (range: [number, number], value: number) => boolean;
+export { normalizeRange, within };
+//# sourceMappingURL=range.d.ts.map

package/dist/services/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/services/range.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,cAAc,GAClB,OAAO,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,MAAM,KACZ,CAAC,MAAM,EAAE,MAAM,CAMjB,CAAC;AAEF,QAAA,MAAM,MAAM,GAAI,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,MAAM,KAAG,OACjB,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,CAAC"}

package/dist/services/range.js

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

package/dist/services/truncateLargeFields.d.ts

@@ -1,32 +1,3 @@
-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"}}'
- * ```
- */
-declare const truncateLargeFields: TruncateLargeFieldsFunction;
+declare function truncateLargeFields(jsonString: string, maxLength?: number): string;
 export { truncateLargeFields };
 //# sourceMappingURL=truncateLargeFields.d.ts.map

package/dist/services/truncateLargeFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"truncateLargeFields.d.ts","sourceRoot":"","sources":["../../src/services/truncateLargeFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,mBAAmB,EAAE,2BAgC1B,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"truncateLargeFields.d.ts","sourceRoot":"","sources":["../../src/services/truncateLargeFields.ts"],"names":[],"mappings":"AAAA,iBAAS,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,SAAO,GAAG,MAAM,CA6BzE;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/services/truncateLargeFields.js

@@ -1,33 +1,5 @@
-/**
- * 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 = (jsonString, maxLength = 1000) => {
-    function truncateValue(value) {
+function truncateLargeFields(jsonString, maxLength = 1000) {
+    function truncateValue(key, value) {
         if (typeof value === "string" && value.length > maxLength) {
             return `To large information: field as ${value.length} characters`;
         }
@@ -35,15 +7,15 @@ const truncateLargeFields = (jsonString, maxLength = 1000) => {
     }
     function recursiveTruncate(obj) {
         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 {
         const parsedJson = JSON.parse(jsonString);
@@ -53,5 +25,5 @@ const truncateLargeFields = (jsonString, maxLength = 1000) => {
     catch (error) {
         throw new Error("Invalid JSON string");
     }
-};
+}
 export { truncateLargeFields };

package/dist/validations/regex.d.ts

@@ -0,0 +1,15 @@
+declare const regex: {
+    URL: RegExp;
+    HOUR: RegExp;
+    RG: RegExp;
+    PHONE: RegExp;
+    PASSWORD: RegExp;
+    DATEHOUR: RegExp;
+    CPF: RegExp;
+    CNPJ: RegExp;
+    CEP: RegExp;
+    CPFCNPJ: RegExp;
+    DATE: RegExp;
+};
+export { regex };
+//# sourceMappingURL=regex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/validations/regex.ts"],"names":[],"mappings":"AA0BA,QAAA,MAAM,KAAK;;;;;;;;;;;;CAYV,CAAC;AAEF,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/validations/regex.js

@@ -0,0 +1,25 @@
+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/dist/validations/validateCPF.d.ts

@@ -0,0 +1,3 @@
+declare function validateCPF(rawCpf: string): boolean;
+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":"AA2BA,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,WAQlC;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCPF.js

@@ -0,0 +1,36 @@
+function removeNonDigits(cpf) {
+    return cpf.replace(/\D/g, "");
+}
+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);
+}
+function validateCPF(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/dist/validations/validateDate.d.ts

@@ -1,29 +1,8 @@
-import type { ValidateDateFunction } from "@arkyn/types";
-/**
- * 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)
- * ```
- */
-declare const validateDate: ValidateDateFunction;
+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;
 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,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"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"}

package/dist/validations/validateDate.js

@@ -1,46 +1,20 @@
-/**
- * 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)
- * ```
- */
-const validateDate = (date, config) => {
+function validateDate(date, format, config) {
     let day, month, year;
-    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;
@@ -69,5 +43,5 @@ const validateDate = (date, config) => {
         return false;
     const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
     return isValidDate;
-};
+}
 export { validateDate };

package/dist/validations/validatePhone.d.ts

@@ -1,29 +1,3 @@
-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
- * ```
- */
-declare const validatePhone: ValidatePhoneFunction;
+declare function validatePhone(phone: string): boolean;
 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":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"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"}

package/dist/validations/validatePhone.js

@@ -1,30 +1,5 @@
 import { countries } from "@arkyn/templates";
-/**
- * Validates a phone number against a list of country-specific formats.
- *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @param 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 = (phone) => {
+function validatePhone(phone) {
     for (const country of countries) {
         const countryCode = country.code;
         const prefix = country.prefix ? `-${country.prefix}` : "";
@@ -40,5 +15,5 @@ const validatePhone = (phone) => {
             return true;
     }
     return false;
-};
+}
 export { validatePhone };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkyn/shared",
-  "version": "1.4.57",
+  "version": "1.5.0",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
@@ -8,12 +8,10 @@
   "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": {
-    "uuid": "^10.0.0",
-    "vitest": "^3.1.1"
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@types/uuid": "^10.0.0",

package/src/formats/formatBrazilianDateHour.ts

@@ -0,0 +1,17 @@
+import { regex } from "../validations/regex";
+
+function formatBrazilianDateHour(date: string, hour: string) {
+  if (regex.HOUR.test(hour) === false) throw new Error("Invalid hour format");
+
+  const [day, month, year] = date.split("/").map(Number);
+
+  const dateHour = new Date(`${year}-${month}-${day}`);
+  const [hours, minutes] = hour.split(":").map(Number);
+
+  dateHour.setUTCHours(hours);
+  dateHour.setUTCMinutes(minutes);
+
+  return dateHour;
+}
+
+export { formatBrazilianDateHour };

package/src/formats/formatBrazilianDateToDate.ts

@@ -0,0 +1,13 @@
+import { regex } from "../validations/regex";
+
+function formatBrazilianDateToDate(brazilianData: string) {
+  if (regex.DATE.test(brazilianData) === false)
+    throw new Error("Invalid date format");
+
+  const [day, month, year] = brazilianData.split("/").map(Number);
+  const formattedDate = `${year}-${month}-${day}`;
+
+  return new Date(formattedDate);
+}
+
+export { formatBrazilianDateToDate };

package/src/formats/formatDateHour.ts

@@ -0,0 +1,15 @@
+import { regex } from "../validations/regex";
+
+function formatDateHour(date: string, hour: string = "00:00") {
+  if (regex.HOUR.test(hour) === false) throw new Error("Invalid hour format");
+
+  const dateHour = new Date(date);
+  const [hours, minutes] = hour.split(":").map(Number);
+
+  dateHour.setUTCHours(hours);
+  dateHour.setUTCMinutes(minutes);
+
+  return dateHour;
+}
+
+export { formatDateHour };

package/src/formats/formatJsonObject.ts

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