@arkyn/shared 2.0.1-beta.0 → 2.0.1-beta.1

package/dist/services/truncateLargeFields.js

@@ -0,0 +1,57 @@
+/**
+ * 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) {
+        if (typeof value === "string" && value.length > maxLength) {
+            return `To large information: field as ${value.length} characters`;
+        }
+        return value;
+    }
+    function recursiveTruncate(obj) {
+        if (Array.isArray(obj)) {
+            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,
+                recursiveTruncate(value), // Corrigido para aplicar recursão corretamente
+            ]));
+        }
+        return truncateValue(obj); // Corrigido para truncar valores diretamente
+    }
+    try {
+        const parsedJson = JSON.parse(jsonString);
+        const truncatedJson = recursiveTruncate(parsedJson);
+        return JSON.stringify(truncatedJson);
+    }
+    catch (error) {
+        throw new Error("Invalid JSON string");
+    }
+};
+export { truncateLargeFields };

package/dist/validations/__test__/validateCpf.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validateCpf.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateCpf.spec.d.ts","sourceRoot":"","sources":["../../../src/validations/__test__/validateCpf.spec.ts"],"names":[],"mappings":""}

package/dist/validations/__test__/validateCpf.spec.js

@@ -0,0 +1,31 @@
+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/dist/validations/__test__/validateDate.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validateDate.spec.d.ts.map

package/dist/validations/__test__/validateDate.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateDate.spec.d.ts","sourceRoot":"","sources":["../../../src/validations/__test__/validateDate.spec.ts"],"names":[],"mappings":""}

package/dist/validations/__test__/validateDate.spec.js

@@ -0,0 +1,44 @@
+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" })).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/dist/validations/__test__/validatePhone.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validatePhone.spec.d.ts.map

package/dist/validations/__test__/validatePhone.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validatePhone.spec.d.ts","sourceRoot":"","sources":["../../../src/validations/__test__/validatePhone.spec.ts"],"names":[],"mappings":""}

package/dist/validations/__test__/validatePhone.spec.js

@@ -0,0 +1,32 @@
+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/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;AA6BxD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAWlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -0,0 +1,56 @@
+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);
+}
+/**
+ * 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 = 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

@@ -0,0 +1,29 @@
+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;
+export { validateDate };
+//# sourceMappingURL=validateDate.d.ts.map

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

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

package/dist/validations/validateDate.js

@@ -0,0 +1,73 @@
+/**
+ * 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) => {
+    let day, month, year;
+    const inputFormat = config?.inputFormat || "DD/MM/YYYY";
+    const minYear = config?.minYear || 1900;
+    const maxYear = config?.maxYear || 3000;
+    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 (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 (inputFormat === "YYYY-MM-DD") {
+        const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+        if (!dateRegex.test(date))
+            return false;
+        [, year, month, day] = date.match(dateRegex) || [];
+    }
+    else {
+        throw new Error("Invalid date format");
+    }
+    const dayNum = parseInt(day, 10);
+    const monthNum = parseInt(month, 10);
+    const yearNum = parseInt(year, 10);
+    if (dayNum < 1 || dayNum > 31)
+        return false;
+    if (monthNum < 1 || monthNum > 12)
+        return false;
+    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (monthNum === 2) {
+        const isLeapYear = (yearNum % 4 === 0 && yearNum % 100 !== 0) || yearNum % 400 === 0;
+        if (dayNum > (isLeapYear ? 29 : 28))
+            return false;
+    }
+    else if (dayNum > daysInMonth[monthNum - 1]) {
+        return false;
+    }
+    if (yearNum < minYear || yearNum > maxYear)
+        return false;
+    const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
+    return isValidDate;
+};
+export { validateDate };

package/dist/validations/validatePhone.d.ts

@@ -0,0 +1,29 @@
+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;
+export { validatePhone };
+//# sourceMappingURL=validatePhone.d.ts.map

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

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

package/dist/validations/validatePhone.js

@@ -0,0 +1,44 @@
+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) => {
+    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))
+                return true;
+            continue;
+        }
+        const regex = new RegExp(`^\\${countryCode}${prefix} \\d{${digitCount}}$`);
+        if (regex.test(phone))
+            return true;
+    }
+    return false;
+};
+export { validatePhone };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkyn/shared",
-  "version": "2.0.1-beta.0",
+  "version": "2.0.1-beta.1",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",