@arkyn/shared 3.0.1-beta.155 → 3.0.1-beta.156

package/dist/formats/formatJsonObject.js

@@ -1,89 +0,0 @@
-/**
- * Formats a JSON object into a human-readable string with proper indentation.
- *
- * - 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.
- *
- * @param json - The value to format: object, array, string, or primitive.
- * @param indentLevel - Current indentation depth (used recursively; pass `0` at the top level).
- * @returns A pretty-printed string representation of the value.
- *
- * @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 = (json, indentLevel) => {
-    const indent = "  ".repeat(indentLevel);
-    let formattedString = "";
-    if (typeof json === "object" && json !== null) {
-        if (Array.isArray(json)) {
-            if (json.length === 0) {
-                // Caso especial para arrays vazios
-                formattedString += "[]";
-            }
-            else {
-                formattedString += "[\n";
-                json.forEach((item, index) => {
-                    formattedString +=
-                        indent + "  " + formatJsonObject(item, indentLevel + 1);
-                    if (index < json.length - 1) {
-                        formattedString += ",";
-                    }
-                    formattedString += "\n";
-                });
-                formattedString += indent + "]";
-            }
-        }
-        else {
-            const keys = Object.keys(json);
-            if (keys.length === 0) {
-                // Caso especial para objetos vazios
-                formattedString += "{}";
-            }
-            else {
-                formattedString += "{\n";
-                keys.forEach((key, index) => {
-                    formattedString +=
-                        indent +
-                            '  "' +
-                            key +
-                            '": ' +
-                            formatJsonObject(json[key], indentLevel + 1);
-                    if (index < keys.length - 1) {
-                        formattedString += ",";
-                    }
-                    formattedString += "\n";
-                });
-                formattedString += indent + "}";
-            }
-        }
-    }
-    else if (typeof json === "string") {
-        try {
-            const parsedObj = JSON.parse(json);
-            formattedString += formatJsonObject(parsedObj, indentLevel);
-        }
-        catch {
-            formattedString += '"' + json + '"';
-        }
-    }
-    else {
-        formattedString += json;
-    }
-    return formattedString;
-};
-export { formatJsonObject };

package/dist/formats/formatJsonString.js

@@ -1,30 +0,0 @@
-import { formatJsonObject } from "./formatJsonObject";
-/**
- * Parses a JSON string and returns a human-readable pretty-printed representation.
- * Throws if the input is not valid JSON.
- *
- * @param jsonString - A valid JSON string to format.
- * @returns A pretty-printed string representation.
- *
- * @example
- * ```typescript
- * formatJsonString('{"name":"John","hobbies":["reading","gaming"]}');
- * // {
- * //   "name": "John",
- * //   "hobbies": [
- * //     "reading",
- * //     "gaming"
- * //   ]
- * // }
- * ```
- */
-const formatJsonString = (jsonString) => {
-    try {
-        const jsonObject = JSON.parse(jsonString);
-        return formatJsonObject(jsonObject, 0);
-    }
-    catch (error) {
-        throw new Error(`Invalid JSON string \n ${error}`);
-    }
-};
-export { formatJsonString };

package/dist/formats/formatToCapitalizeFirstWordLetter.js

@@ -1,23 +0,0 @@
-/**
- * Capitalizes the first letter of each word and lowercases the rest.
- * Words are separated by spaces.
- *
- * @param sentence - The string to format.
- * @returns The sentence with every word title-cased.
- *
- * @example
- * ```typescript
- * formatToCapitalizeFirstWordLetter("hello world");  // "Hello World"
- * formatToCapitalizeFirstWordLetter("HELLO WORLD");  // "Hello World"
- * ```
- */
-function formatToCapitalizeFirstWordLetter(sentence) {
-    const words = sentence.split(" ");
-    const capitalizedWords = words.map((word) => {
-        const firstLetter = word.charAt(0).toUpperCase();
-        const restOfWord = word.slice(1).toLowerCase();
-        return firstLetter + restOfWord;
-    });
-    return capitalizedWords.join(" ");
-}
-export { formatToCapitalizeFirstWordLetter };

package/dist/formats/formatToCep.js

@@ -1,28 +0,0 @@
-import { removeNonNumeric } from "../utilities/removeNonNumeric";
-/**
- * Formats a given string into a Brazilian postal code (CEP) format.
- *
- * The function removes all non-numeric characters from the input string
- * and attempts to format it as a CEP in the pattern `XXXXX-XXX`.
- * If the input does not match the expected format, an error is thrown.
- *
- * @param value - Input string with 8 numeric digits (special characters are stripped).
- * @returns The formatted CEP string in the pattern `XXXXX-XXX`.
- *
- * @throws {Error} If the input does not match the expected CEP format.
- *
- * @example
- * ```typescript
- * const formattedCep = formatToCep("12345678");
- * console.log(formattedCep); // Output: "12345-678"
- * ```
- */
-function formatToCep(value) {
-    const cleaned = removeNonNumeric(value);
-    const match = cleaned.match(/^(\d{5})(\d{3})$/);
-    const errorMessage = `CEP must be contain 8 numeric digits: ${value}`;
-    if (!match)
-        throw new Error(errorMessage);
-    return `${match[1]}-${match[2]}`;
-}
-export { formatToCep };

package/dist/formats/formatToCnpj.js

@@ -1,26 +0,0 @@
-import { removeNonNumeric } from "../utilities/removeNonNumeric";
-/**
- * Formats a given string or number into a CNPJ (Cadastro Nacional da Pessoa Jurídica) format.
- *
- * The CNPJ format is: `XX.XXX.XXX/XXXX-XX`, where `X` represents a digit.
- *
- * @param value - Input string with 14 numeric digits (special characters are stripped).
- * @returns The formatted CNPJ string in the pattern `XX.XXX.XXX/XXXX-XX`.
- *
- * @throws {Error} Throws an error if the input does not contain exactly 14 numeric digits.
- *
- * @example
- * ```typescript
- * const formattedCnpj = formatToCnpj("12345678000195");
- * console.log(formattedCnpj); // Output: "12.345.678/0001-95"
- * ```
- */
-function formatToCnpj(value) {
-    const cleaned = removeNonNumeric(value);
-    const match = cleaned.match(/^(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/);
-    const errorMessage = `CNPJ must be contain 14 numeric digits: ${value}`;
-    if (!match)
-        throw new Error(errorMessage);
-    return `${match[1]}.${match[2]}.${match[3]}/${match[4]}-${match[5]}`;
-}
-export { formatToCnpj };

package/dist/formats/formatToCpf.js

@@ -1,28 +0,0 @@
-import { removeNonNumeric } from "../utilities/removeNonNumeric";
-/**
- * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
- *
- * A CPF is a Brazilian individual taxpayer registry identification format.
- * This function ensures the input is cleaned of non-numeric characters and
- * then formats it into the standard CPF format: `XXX.XXX.XXX-XX`.
- *
- * @param value - Input string with 11 numeric digits (special characters are stripped).
- * @returns The formatted CPF string in the pattern `XXX.XXX.XXX-XX`.
- *
- * @throws {Error} If the input string does not match the expected CPF format.
- *
- * @example
- * ```typescript
- * const formattedCpf = formatToCpf("12345678909");
- * console.log(formattedCpf); // Output: "123.456.789-09"
- * ```
- */
-function formatToCpf(value) {
-    const cleaned = removeNonNumeric(value);
-    const match = cleaned.match(/^(\d{3})(\d{3})(\d{3})(\d{2})$/);
-    const errorMessage = `CPF must be contain 11 numeric digits: ${value}`;
-    if (!match)
-        throw new Error(errorMessage);
-    return `${match[1]}.${match[2]}.${match[3]}-${match[4]}`;
-}
-export { formatToCpf };

package/dist/formats/formatToCurrency.js

@@ -1,31 +0,0 @@
-import { countryCurrencies } from "@arkyn/templates";
-import { removeCurrencySymbols } from "../utilities/removeCurrencySymbols";
-/**
- * Formats a number into a locale-aware currency string using `Intl.NumberFormat`.
- *
- * @param value - The numeric value to format.
- * @param currency - A currency code from `@arkyn/templates` (e.g. `"BRL"`, `"USD"`).
- * @param config.showPrefix - Whether to include the currency symbol. Defaults to `true`.
- * @returns The formatted currency string.
- *
- * @example
- * ```typescript
- * formatToCurrency(1234.56, "BRL"); // "R$ 1.234,56"
- * formatToCurrency(1234.56, "USD", { showPrefix: false }); // "1,234.56"
- * ```
- */
-function formatToCurrency(value, currency, config) {
-    if (!countryCurrencies?.[currency]) {
-        throw new Error("Unsupported currency code");
-    }
-    const showPrefix = config?.showPrefix ?? true;
-    const { countryCurrency, countryLanguage } = countryCurrencies[currency];
-    const format = new Intl.NumberFormat(countryLanguage, {
-        style: "currency",
-        currency: countryCurrency,
-    }).format(value);
-    return showPrefix
-        ? format.replace(/\s/g, " ")
-        : removeCurrencySymbols(format).replace(/\s/g, " ");
-}
-export { formatToCurrency };

package/dist/formats/formatToEllipsis.js

@@ -1,32 +0,0 @@
-/**
- * Truncates a given text to a specified maximum length and appends an ellipsis ("...")
- * if the text exceeds the maximum length.
- *
- * @param text - The input string to be truncated.
- * @param maxLength - Maximum allowed length before truncation.
- * @returns The truncated string with `"..."` appended, or the original string if it fits.
- * @example
- * ```typescript
- * const result = formatToEllipsis("Hello, world!", 5);
- * console.log(result); // Output: "Hello..."
- * ```
- */
-function formatToEllipsis(text, maxLength) {
-    if (text.length > maxLength) {
-        let trimmedText = text.substring(0, maxLength);
-        // Find the last space to avoid breaking words
-        const lastSpaceIndex = trimmedText.lastIndexOf(" ");
-        if (lastSpaceIndex > 0) {
-            trimmedText = trimmedText.substring(0, lastSpaceIndex);
-        }
-        // Remove trailing punctuation
-        trimmedText = trimmedText.replace(/[\s.,!?;:]+$/, "");
-        // If after removing punctuation the text is empty or only contains punctuation/spaces, return only "..."
-        if (trimmedText.trim().length === 0 || /^[.,!?;:\s]+$/.test(trimmedText)) {
-            return "...";
-        }
-        return `${trimmedText}...`;
-    }
-    return text;
-}
-export { formatToEllipsis };

package/dist/formats/formatToHiddenDigits.js

@@ -1,49 +0,0 @@
-const DIGIT = /^\d$/;
-const parseToCharacters = (value) => {
-    let digits = 0;
-    const children = value
-        .split("")
-        .map((character) => {
-        if (DIGIT.test(character))
-            return { character, kind: "digit", digit: ++digits };
-        return { character, kind: "other" };
-    });
-    return { digits, children, kind: "root" };
-};
-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];
-/**
- * Replaces specific digits in a string with a masking character, leaving non-digit characters unchanged.
- *
- * @param value - The input string to mask.
- * @param options.range - Which digits to hide:
- *   - Positive number `n` — hides the first `n` digits.
- *   - Negative number `-n` — hides the last `n` digits.
- *   - Tuple `[start, end]` — hides digits from position `start` to `end` (inclusive, 1-indexed).
- *   - Defaults to `3`.
- * @param options.hider - The masking character. Defaults to `"*"`.
- * @returns The string with the specified digit positions replaced.
- *
- * @example
- * ```typescript
- * formatToHiddenDigits("123-456-7890", { range: 3 });         // "***-456-7890"
- * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" }); // "123-###-7890"
- * ```
- */
-function formatToHiddenDigits(value, options) {
-    const characters = parseToCharacters(value);
-    const range = normalizeRange(options?.range ?? 3, characters.digits);
-    const mappedCharacters = characters.children.map((node) => {
-        if (node.kind === "digit" && within(range, node.digit))
-            return options?.hider ?? "*";
-        return node.character;
-    });
-    return mappedCharacters.join("");
-}
-export { formatToHiddenDigits };

package/dist/formats/formatToPhone.js

@@ -1,43 +0,0 @@
-import { parsePhoneNumberWithError } from "libphonenumber-js";
-import { findCountryMask } from "../utilities/findCountryMask";
-/**
- * Formats a phone number string according to the country mask defined in `@arkyn/templates`.
- *
- * The function parses the input using libphonenumber-js to determine the country and
- * national number, then applies the corresponding country's mask (underscore `_` used
- * as digit placeholder) replacing placeholders with actual digits.
- *
- * @param phoneNumber - The input phone number in E.164 format (e.g. `"+5534920524282"`).
- * @returns The phone number formatted according to the country's mask.
- *
- * @throws {Error} If the phone number is invalid or if no country mask is found for the parsed country.
- *
- * @example
- * ```typescript
- * console.log(formatToPhone("+5534920524282")); // Output: "(34) 92052-4282" (Brazilian format)
- * console.log(formatToPhone("+553420524282")); // Output: "(34) 2052-4282" (Brazilian format with optional ninth digit)
- * console.log(formatToPhone("+12125550199")); // Output: "(212) 555-0199" (American Samoa format)
- * ```
- */
-function formatToPhone(phoneNumber) {
-    try {
-        const parsedPhone = parsePhoneNumberWithError(phoneNumber);
-        const phoneNumberDigits = parsedPhone.nationalNumber.toString();
-        let formattedNumber = findCountryMask(phoneNumber)[0];
-        for (let i = 0, j = 0; i < formattedNumber.length && j < phoneNumberDigits.length; i++) {
-            if (formattedNumber[i] === "_") {
-                formattedNumber =
-                    formattedNumber.substring(0, i) +
-                        phoneNumberDigits[j] +
-                        formattedNumber.substring(i + 1);
-                j++;
-            }
-        }
-        return formattedNumber;
-    }
-    catch (rawError) {
-        const error = rawError;
-        throw new Error(error.message);
-    }
-}
-export { formatToPhone };

package/dist/generators/generateColorByString.js

@@ -1,28 +0,0 @@
-/**
- * Generates a hexadecimal color code based on the input string.
- * The function creates a hash from the string and uses it to calculate
- * RGB values, which are then converted to a hexadecimal color code.
- *
- * @param rawString - The input string used to generate the color.
- * @returns A hexadecimal color code (e.g., `"#a1b2c3"`) derived from the input string.
- *
- * @example
- * ```typescript
- * const color = generateColorByString("example");
- * console.log(color); // Outputs a consistent hex color like "#5e8f9a"
- * ```
- */
-function generateColorByString(rawString) {
-    var hash = 0;
-    for (var i = 0; i < rawString.length; i++) {
-        hash = rawString.charCodeAt(i) + ((hash << 5) - hash);
-    }
-    var red = (hash & 0xff0000) >> 16;
-    var green = (hash & 0x00ff00) >> 8;
-    var blue = hash & 0x0000ff;
-    var redHex = red.toString(16).padStart(2, "0");
-    var greenHex = green.toString(16).padStart(2, "0");
-    var blueHex = blue.toString(16).padStart(2, "0");
-    return "#" + redHex + greenHex + blueHex;
-}
-export { generateColorByString };

package/dist/generators/generateId.js

@@ -1,29 +0,0 @@
-import { v4, v7 } from "uuid";
-function hexToBin(hex) {
-    hex = hex.replace(/-/g, "");
-    const buffer = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-        buffer[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-    }
-    return buffer;
-}
-function uuidV4() {
-    const uuid = v4();
-    return { text: uuid, binary: hexToBin(uuid) };
-}
-function uuidV7() {
-    const uuid = v7();
-    return { text: uuid, binary: hexToBin(uuid) };
-}
-function generateId(type, format) {
-    if (type === "text" && format === "v4")
-        return uuidV4().text;
-    if (type === "binary" && format === "v4")
-        return uuidV4().binary;
-    if (type === "text" && format === "v7")
-        return uuidV7().text;
-    if (type === "binary" && format === "v7")
-        return uuidV7().binary;
-    throw new Error("Invalid type or format");
-}
-export { generateId };

package/dist/generators/generateSlug.js

@@ -1,31 +0,0 @@
-/**
- * Generates a URL-friendly slug from a given string.
- *
- * The function performs the following transformations:
- * - Normalizes the string to remove diacritical marks (e.g., accents).
- * - Removes non-alphanumeric characters except for spaces and hyphens.
- * - Replaces spaces with hyphens.
- * - Converts the string to lowercase.
- * - Collapses multiple consecutive hyphens into a single hyphen.
- * - Trims leading and trailing hyphens.
- *
- * @param rawString - The input string to be converted into a slug.
- * @returns A URL-friendly slug derived from the input string.
- *
- * @example
- * ```typescript
- * const slug = generateSlug("Hello, World! This is a Test.");
- * console.log(slug); // Outputs: "hello-world-this-is-a-test"
- * ```
- */
-function generateSlug(rawString) {
-    let slug = rawString.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-    slug = slug
-        .replace(/[^\w\s-]/g, "")
-        .replace(/\s+/g, "-")
-        .toLowerCase();
-    slug = slug.replace(/-{2,}/g, "-");
-    slug = slug.replace(/^-+|-+$/g, "");
-    return slug;
-}
-export { generateSlug };

package/dist/parsers/parseLargeFields.js

@@ -1,55 +0,0 @@
-/**
- * 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 = parseLargeFields(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"}}'
- * ```
- */
-function parseLargeFields(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));
-        }
-        else if (obj !== null && typeof obj === "object") {
-            return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
-                key,
-                recursiveTruncate(value),
-            ]));
-        }
-        return truncateValue(obj);
-    }
-    try {
-        const parsedJson = JSON.parse(jsonString);
-        const truncatedJson = recursiveTruncate(parsedJson);
-        return JSON.stringify(truncatedJson);
-    }
-    catch (error) {
-        throw new Error("Invalid JSON string");
-    }
-}
-export { parseLargeFields };

package/dist/parsers/parseSensitiveData.js

@@ -1,57 +0,0 @@
-/**
- * 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 - Keys whose values will be replaced with `"****"`. Defaults to `["password", "confirmPassword", "creditCard"]`.
- * @returns A JSON string with sensitive values masked. Returns the original string if it is not valid JSON.
- *
- * @example
- * ```typescript
- * const jsonString = JSON.stringify({
- *   username: "user123",
- *   password: "secret",
- *   profile: { creditCard: "1234-5678-9012-3456" },
- * });
- *
- * const result = parseSensitiveData(jsonString, ["password", "creditCard"]);
- * console.log(result); // Output: '{"username":"user123","password":"****","profile":{"creditCard":"****"}}'
- * ```
- */
-function parseSensitiveData(jsonString, sensitiveKeys = ["password", "confirmPassword", "creditCard"]) {
-    function maskValue(key, value) {
-        if (sensitiveKeys.includes(key))
-            return "****";
-        return value;
-    }
-    function recursiveMask(obj) {
-        if (Array.isArray(obj)) {
-            return obj.map((item) => recursiveMask(item));
-        }
-        else if (obj !== null && typeof obj === "object") {
-            return Object.keys(obj).reduce((acc, key) => {
-                let value = obj[key];
-                if (typeof value === "string") {
-                    try {
-                        const parsedValue = JSON.parse(value);
-                        if (typeof parsedValue === "object") {
-                            value = JSON.stringify(recursiveMask(parsedValue));
-                        }
-                    }
-                    catch (e) { }
-                }
-                acc[key] = recursiveMask(maskValue(key, value));
-                return acc;
-            }, {});
-        }
-        return obj;
-    }
-    try {
-        const jsonObject = JSON.parse(jsonString);
-        const maskedObject = recursiveMask(jsonObject);
-        return JSON.stringify(maskedObject);
-    }
-    catch (error) {
-        return jsonString;
-    }
-}
-export { parseSensitiveData };

package/dist/parsers/parseToDate.js

@@ -1,51 +0,0 @@
-import { ValidateDateService } from "../services/validateDateService";
-/**
- * Parses a date (and optional time) string into a JavaScript `Date` object.
- * All calculations are in UTC+0; use `timezone` to shift the result.
- *
- * @param date - Date string in the format determined by `inputFormat`.
- * @param time - Optional time string `"HH:mm:ss"` (defaults to `"00:00:00"`).
- * @param inputFormat - Parsing format:
- *   - `"brazilianDate"`: DD/MM/YYYY
- *   - `"isoDate"`: MM-DD-YYYY
- *   - `"timestamp"`: YYYY-MM-DD
- * @param timezone - UTC offset in hours (e.g. `-3` for UTC-3). Defaults to `0`.
- * @returns A `Date` object representing the parsed date and time.
- *
- * @example
- * ```typescript
- * parseToDate(["25/12/2023", "15:30:00"], "brazilianDate", -3);
- * // Date: 2023-12-25T12:30:00.000Z
- *
- * parseToDate(["2023-12-25"], "timestamp");
- * // Date: 2023-12-25T00:00:00.000Z
- * ```
- */
-function parseToDate([date, time = "00:00:00"], inputFormat, timezone = 0) {
-    const validateDateService = new ValidateDateService();
-    validateDateService.validateInputFormat(inputFormat);
-    const dateParts = date.split(/[-/]/).map(Number);
-    const timeParts = time.split(".")[0].split(":").map(Number);
-    let day, month, year;
-    const [hours = 0, minutes = 0, seconds = 0] = timeParts;
-    switch (inputFormat) {
-        case "brazilianDate":
-            [day, month, year] = dateParts;
-            validateDateService.validateDateParts(year, month, day);
-            break;
-        case "isoDate":
-            [month, day, year] = dateParts;
-            validateDateService.validateDateParts(year, month, day);
-            break;
-        case "timestamp":
-            [year, month, day] = dateParts;
-            validateDateService.validateDateParts(year, month, day);
-            break;
-    }
-    const formattedDate = new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
-    if (isNaN(formattedDate.getTime()))
-        throw new Error("Invalid date");
-    formattedDate.setUTCHours(formattedDate.getUTCHours() + timezone);
-    return formattedDate;
-}
-export { parseToDate };