@arkyn/shared 1.4.52 → 2.0.1-beta.1

package/dist/formats/formatToCurrency.js

@@ -0,0 +1,41 @@
+import { countryCurrencies } from "@arkyn/templates";
+import { removeCurrencySymbols } from "../services/removeCurrencySymbols";
+/**
+ * Formats a numeric value into a currency string based on the specified currency and configuration.
+ *
+ * @param value - The numeric value to be formatted.
+ * @param currency - The currency code used to determine the formatting style.
+ * @param config - Optional configuration object.
+ * @param config.showPrefix - Determines whether the currency symbol/prefix should be included in the formatted string. Defaults to `true`.
+ *
+ * @returns A formatted currency string. If `config.showPrefix` is `false`, the currency symbol is removed.
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatToCurrency(1234.56, "USD", { showPrefix: true });
+ * console.log(formatted); // "$1,234.56"
+ *
+ * const withoutPrefix = formatToCurrency(1234.56, "USD", { showPrefix: false });
+ * console.log(withoutPrefix); // "1,234.56"
+ *
+ * const formattedBRL = formatToCurrency(1234.56, "BRL", { showPrefix: true });
+ * console.log(formattedBRL); // "R$ 1.234,56"
+ *
+ * const withoutPrefixBRL = formatToCurrency(1234.56, "BRL", { showPrefix: false });
+ * console.log(withoutPrefixBRL); // "1.234,56"
+ * ```
+ */
+const formatToCurrency = (value, currency, config = { showPrefix: true }) => {
+    if (!countryCurrencies[currency]) {
+        throw new Error("Unsupported currency code");
+    }
+    const { countryCurrency, countryLanguage } = countryCurrencies[currency];
+    const format = new Intl.NumberFormat(countryLanguage, {
+        style: "currency",
+        currency: countryCurrency,
+    }).format(value);
+    return config.showPrefix
+        ? format.replace(/\s/g, " ")
+        : removeCurrencySymbols(format).replace(/\s/g, " ");
+};
+export { formatToCurrency };

package/dist/formats/formatToEllipsis.d.ts

@@ -1,3 +1,16 @@
-declare function formatToEllipsis(text: string, size?: number): string;
+import type { FormatToEllipsisFunction } from "@arkyn/types";
+/**
+ * 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 - The maximum allowed length of the string before truncation.
+ * @returns The truncated string with an ellipsis if the input exceeds the maximum length,
+ *          or the original string if it does not.
+ * @example
+ * const result = formatToEllipsis("Hello, world!", 5);
+ * console.log(result); // Output: "Hello..."
+ */
+declare const formatToEllipsis: FormatToEllipsisFunction;
 export { formatToEllipsis };
 //# sourceMappingURL=formatToEllipsis.d.ts.map

package/dist/formats/formatToEllipsis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToEllipsis.d.ts","sourceRoot":"","sources":["../../src/formats/formatToEllipsis.ts"],"names":[],"mappings":"AAAA,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAEzD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatToEllipsis.d.ts","sourceRoot":"","sources":["../../src/formats/formatToEllipsis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D;;;;;;;;;;;GAWG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToEllipsis.js

@@ -1,4 +1,21 @@
-function formatToEllipsis(text, size = 40) {
-    return text.length > size ? `${text.substring(0, size)}...` : text;
-}
+/**
+ * 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 - The maximum allowed length of the string before truncation.
+ * @returns The truncated string with an ellipsis if the input exceeds the maximum length,
+ *          or the original string if it does not.
+ * @example
+ * const result = formatToEllipsis("Hello, world!", 5);
+ * console.log(result); // Output: "Hello..."
+ */
+const formatToEllipsis = (text, maxLength) => {
+    if (text.length > maxLength) {
+        let trimmedText = text.substring(0, maxLength).trimEnd();
+        trimmedText = trimmedText.replace(/[.,!?;:]$/, "");
+        return `${trimmedText}...`;
+    }
+    return text;
+};
 export { formatToEllipsis };

package/dist/formats/formatToHiddenDigits.d.ts

@@ -1,4 +1,32 @@
-import type { FormatToHiddenDigitsOptions } from "@arkyn/types";
-declare const formatToHiddenDigits: (value: string, options?: FormatToHiddenDigitsOptions) => string;
+import type { FormatToHiddenDigitsFunction } from "@arkyn/types";
+/**
+ * Formats a string by hiding specific digits within a given range.
+ *
+ * This function takes a string input and replaces digits within a specified range
+ * with a hiding character (e.g., "*"). Non-digit characters remain unchanged.
+ *
+ * @param value - The input string to be formatted.
+ * @param options - Configuration options for formatting.
+ * @param options.range - The range of digits to hide. It can be:
+ *   - A single number (e.g., `3`), which hides the first `n` digits if positive,
+ *     or the last `n` digits if negative.
+ *   - A tuple `[start, end]` specifying the range of digits to hide (inclusive).
+ *   - Defaults to `3`, hiding the first three digits.
+ * @param options.hider - The character used to hide digits. Defaults to `"*"`.
+ *
+ * @returns The formatted string with specified digits hidden.
+ *
+ * @example
+ * ```typescript
+ * import { formatToHiddenDigits } from "./formatToHiddenDigits";
+ *
+ * formatToHiddenDigits("123-456-7890", { range: 3 });
+ * // Output: "***-456-7890"
+ *
+ * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
+ * // Output: "123-###-7890"
+ * ```
+ */
+declare const formatToHiddenDigits: FormatToHiddenDigitsFunction;
 export { formatToHiddenDigits };
 //# sourceMappingURL=formatToHiddenDigits.d.ts.map

package/dist/formats/formatToHiddenDigits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToHiddenDigits.d.ts","sourceRoot":"","sources":["../../src/formats/formatToHiddenDigits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAKhE,QAAA,MAAM,oBAAoB,GACxB,OAAO,MAAM,EACb,UAAS,2BAAgC,KACxC,MAUF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"formatToHiddenDigits.d.ts","sourceRoot":"","sources":["../../src/formats/formatToHiddenDigits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AA+CjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,oBAAoB,EAAE,4BAU3B,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/formats/formatToHiddenDigits.js

@@ -1,6 +1,52 @@
-import { parseToCharacters } from "../parsers/parseToCharacters";
-import { normalizeRange, within } from "../services/range";
-const formatToHiddenDigits = (value, options = {}) => {
+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];
+/**
+ * Formats a string by hiding specific digits within a given range.
+ *
+ * This function takes a string input and replaces digits within a specified range
+ * with a hiding character (e.g., "*"). Non-digit characters remain unchanged.
+ *
+ * @param value - The input string to be formatted.
+ * @param options - Configuration options for formatting.
+ * @param options.range - The range of digits to hide. It can be:
+ *   - A single number (e.g., `3`), which hides the first `n` digits if positive,
+ *     or the last `n` digits if negative.
+ *   - A tuple `[start, end]` specifying the range of digits to hide (inclusive).
+ *   - Defaults to `3`, hiding the first three digits.
+ * @param options.hider - The character used to hide digits. Defaults to `"*"`.
+ *
+ * @returns The formatted string with specified digits hidden.
+ *
+ * @example
+ * ```typescript
+ * import { formatToHiddenDigits } from "./formatToHiddenDigits";
+ *
+ * formatToHiddenDigits("123-456-7890", { range: 3 });
+ * // Output: "***-456-7890"
+ *
+ * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
+ * // Output: "123-###-7890"
+ * ```
+ */
+const formatToHiddenDigits = (value, options) => {
     const characters = parseToCharacters(value);
     const range = normalizeRange(options.range ?? 3, characters.digits);
     return characters.children

package/dist/formats/formatToPhone.d.ts

@@ -1,3 +1,34 @@
-declare function formatToPhone(value: string): string;
+import type { FormatToPhoneFunction } from "@arkyn/types";
+/**
+ * Formats a phone number string based on the provided country code and optional prefix.
+ *
+ * The input string should follow the format: `"<countryCode>-<prefix> <phoneNumber>"` or `"<countryCode> <phoneNumber>"`.
+ * The function determines the appropriate formatting mask based on the country and applies it to the phone number.
+ *
+ * @param prop - The phone number string to be formatted. It must include the country code and optionally a prefix.
+ *               Example formats:
+ *               - "+55-11 912345678"
+ *               - "+1 1234567890"
+ *
+ * @returns The formatted phone number string based on the country's formatting rules.
+ *
+ * @throws {Error} If the input phone number does not match the expected format.
+ * @throws {Error} If the country code or phone number is missing from the input string.
+ * @throws {Error} If the provided country code and prefix combination is invalid.
+ * @throws {Error} If the provided country code is invalid.
+ * @throws {Error} If the provided country code has a prefix but none is supplied in the input.
+ *
+ * @example
+ * ```typescript
+ * import { formatToPhone } from "./formatToPhone";
+ *
+ * const formattedPhone1 = formatToPhone("+55 11912345678");
+ * console.log(formattedPhone1); // Output: "(11) 91234-5678" (brazilian phone number format)
+ *
+ * const formattedPhone2 = formatToPhone("+1-123 4567890");
+ * console.log(formattedPhone2); // Output: "(123) 456-7890" (us phone number format)
+ * ```
+ */
+declare const formatToPhone: FormatToPhoneFunction;
 export { formatToPhone };
 //# sourceMappingURL=formatToPhone.d.ts.map

package/dist/formats/formatToPhone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToPhone.d.ts","sourceRoot":"","sources":["../../src/formats/formatToPhone.ts"],"names":[],"mappings":"AAAA,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"formatToPhone.d.ts","sourceRoot":"","sources":["../../src/formats/formatToPhone.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAqGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAwBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/formats/formatToPhone.js

@@ -1,9 +1,131 @@
-function formatToPhone(value) {
-    const cleaned = value.replace(/\D/g, "");
-    const match = cleaned.match(/^(\d{2})(\d{5})(\d{4})$/);
-    if (match) {
-        return `(${match[1]}) ${match[2]}-${match[3]}`;
+import { countries } from "@arkyn/templates";
+import { removeNonNumeric } from "../services/removeNonNumeric";
+function getMask(value) {
+    const mask = value.length > 10 ? "NINE" : "EIGTH";
+    return mask;
+}
+const TYPES = {
+    EIGTH: "(99) 9999-9999",
+    NINE: "(99) 99999-9999",
+};
+const MAX_LENGTH = removeNonNumeric(TYPES.NINE).length;
+function applyMask(value, maskPattern) {
+    let result = "";
+    let digitIndex = 0;
+    for (let i = 0; i < maskPattern.length; i++) {
+        if (maskPattern[i] === "9") {
+            if (digitIndex < value.length) {
+                result += value[digitIndex];
+                digitIndex++;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            if (digitIndex < value.length) {
+                result += maskPattern[i];
+            }
+            else {
+                break;
+            }
+        }
+    }
+    return result;
+}
+function formatPhoneNumber(phoneNumber, country) {
+    if (country.code === "+55") {
+        let value = removeNonNumeric(phoneNumber);
+        const mask = getMask(value);
+        let nextLength = value.length;
+        if (nextLength > MAX_LENGTH)
+            return value;
+        value = applyMask(value, TYPES[mask]);
+        return value;
+    }
+    const mask = country.mask;
+    let formattedNumber = mask;
+    if (country.prefix) {
+        const prefixRegex = /\$+/g;
+        formattedNumber = formattedNumber.replace(prefixRegex, country.prefix);
+    }
+    for (let i = 0, j = 0; i < formattedNumber.length && j < phoneNumber.length; i++) {
+        if (formattedNumber[i] === "_") {
+            formattedNumber =
+                formattedNumber.substring(0, i) +
+                    phoneNumber[j] +
+                    formattedNumber.substring(i + 1);
+            j++;
+        }
+    }
+    return formattedNumber;
+}
+function getCountryWithPrefixCode(countryCode, prefix) {
+    const country = countries.find((country) => country.code === countryCode && country.prefix === prefix);
+    if (!country)
+        throw new Error("Invalid country code or prefix");
+    if (country.prefix !== prefix) {
+        throw new Error("Invalid country code or prefix");
+    }
+    if (!country.prefix) {
+        throw new Error("Invalid country code or prefix");
     }
-    return value;
+    return country;
+}
+function getCountryWithoutPrefixCode(countryCode) {
+    const country = countries.find((country) => country.code === countryCode);
+    if (!country)
+        throw new Error("Invalid country code");
+    if (country.prefix)
+        throw new Error("Invalid country code");
+    return country;
 }
+/**
+ * Formats a phone number string based on the provided country code and optional prefix.
+ *
+ * The input string should follow the format: `"<countryCode>-<prefix> <phoneNumber>"` or `"<countryCode> <phoneNumber>"`.
+ * The function determines the appropriate formatting mask based on the country and applies it to the phone number.
+ *
+ * @param prop - The phone number string to be formatted. It must include the country code and optionally a prefix.
+ *               Example formats:
+ *               - "+55-11 912345678"
+ *               - "+1 1234567890"
+ *
+ * @returns The formatted phone number string based on the country's formatting rules.
+ *
+ * @throws {Error} If the input phone number does not match the expected format.
+ * @throws {Error} If the country code or phone number is missing from the input string.
+ * @throws {Error} If the provided country code and prefix combination is invalid.
+ * @throws {Error} If the provided country code is invalid.
+ * @throws {Error} If the provided country code has a prefix but none is supplied in the input.
+ *
+ * @example
+ * ```typescript
+ * import { formatToPhone } from "./formatToPhone";
+ *
+ * const formattedPhone1 = formatToPhone("+55 11912345678");
+ * console.log(formattedPhone1); // Output: "(11) 91234-5678" (brazilian phone number format)
+ *
+ * const formattedPhone2 = formatToPhone("+1-123 4567890");
+ * console.log(formattedPhone2); // Output: "(123) 456-7890" (us phone number format)
+ * ```
+ */
+const formatToPhone = (prop) => {
+    const phoneRegex = /^\+\d{1,4}(-\d{1,4})? \d+$/;
+    if (!phoneRegex.test(prop)) {
+        throw new Error("Invalid phone number format. Expected format: +<countryCode>-<optionalPrefix> <phoneNumber>");
+    }
+    const countryCode = prop.split(" ")[0].split("-")[0];
+    const prefixCode = prop.split(" ")[0].split("-")[1];
+    const phoneNumber = prop.split(" ")[1];
+    if (!countryCode || !phoneNumber) {
+        throw new Error("Invalid phone number format");
+    }
+    if (prefixCode) {
+        const country = getCountryWithPrefixCode(countryCode, prefixCode);
+        return formatPhoneNumber(phoneNumber, country);
+    }
+    const country = getCountryWithoutPrefixCode(countryCode);
+    return formatPhoneNumber(phoneNumber, country);
+};
 export { formatToPhone };

package/dist/generators/__test__/generateColorByString.spec.d.ts

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

package/dist/generators/__test__/generateColorByString.spec.d.ts.map

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

package/dist/generators/__test__/generateColorByString.spec.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { generateColorByString } from "../generateColorByString";
+describe("generateColorByString", () => {
+    it("should generate a consistent hex color for the same input string", () => {
+        const color1 = generateColorByString("example");
+        const color2 = generateColorByString("example");
+        expect(color1).toBe(color2);
+    });
+    it("should generate different hex colors for different input strings", () => {
+        const color1 = generateColorByString("example1");
+        const color2 = generateColorByString("example2");
+        expect(color1).not.toBe(color2);
+    });
+    it("should return a valid hex color code", () => {
+        const color = generateColorByString("test");
+        expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+    });
+    it("should handle empty strings and return a valid hex color", () => {
+        const color = generateColorByString("");
+        expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+    });
+    it("should handle strings with special characters", () => {
+        const color = generateColorByString("!@#$%^&*()");
+        expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+    });
+    it("should handle long strings and return a valid hex color", () => {
+        const longString = "a".repeat(1000);
+        const color = generateColorByString(longString);
+        expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+    });
+});

package/dist/generators/__test__/generateId.spec.d.ts

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

package/dist/generators/__test__/generateId.spec.d.ts.map

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

package/dist/generators/__test__/generateId.spec.js

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

package/dist/generators/__test__/generateSlug.spec.d.ts

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

package/dist/generators/__test__/generateSlug.spec.d.ts.map

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

package/dist/generators/__test__/generateSlug.spec.js

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

package/dist/generators/generateColorByString.d.ts

@@ -1,3 +1,15 @@
-declare function generateColorByString(string: string): string;
+import type { GenerateColorByStringFunction } from "@arkyn/types";
+/**
+ * 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 prop - The input string used to generate the color.
+ * @returns A hexadecimal color code (e.g., "#a1b2c3") derived from the input string.
+ * @example
+ * const color = generateColorByString("example");
+ * console.log(color); // Outputs a consistent hex color like "#5e8f9a"
+ */
+declare const generateColorByString: GenerateColorByStringFunction;
 export { generateColorByString };
 //# sourceMappingURL=generateColorByString.d.ts.map

package/dist/generators/generateColorByString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateColorByString.d.ts","sourceRoot":"","sources":["../../src/generators/generateColorByString.ts"],"names":[],"mappings":"AAAA,iBAAS,qBAAqB,CAAC,MAAM,EAAE,MAAM,UAgB5C;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"generateColorByString.d.ts","sourceRoot":"","sources":["../../src/generators/generateColorByString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAElE;;;;;;;;;;GAUG;AAEH,QAAA,MAAM,qBAAqB,EAAE,6BAgB5B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/generators/generateColorByString.js

@@ -1,7 +1,18 @@
-function generateColorByString(string) {
+/**
+ * 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 prop - The input string used to generate the color.
+ * @returns A hexadecimal color code (e.g., "#a1b2c3") derived from the input string.
+ * @example
+ * const color = generateColorByString("example");
+ * console.log(color); // Outputs a consistent hex color like "#5e8f9a"
+ */
+const generateColorByString = (prop) => {
     var hash = 0;
-    for (var i = 0; i < string.length; i++) {
-        hash = string.charCodeAt(i) + ((hash << 5) - hash);
+    for (var i = 0; i < prop.length; i++) {
+        hash = prop.charCodeAt(i) + ((hash << 5) - hash);
     }
     var red = (hash & 0xff0000) >> 16;
     var green = (hash & 0x00ff00) >> 8;
@@ -10,5 +21,5 @@ function generateColorByString(string) {
     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.d.ts

@@ -1,6 +1,28 @@
-declare function generateId(type: "text" | "binary"): {
-    v4: string | Uint8Array<ArrayBuffer>;
-    v7: string | Uint8Array<ArrayBuffer>;
-};
+/**
+ * Generates a unique identifier (UUID) in the specified format and type.
+ *
+ * @param type - The desired output type of the UUID. Can be:
+ *   - `"text"`: Returns the UUID as a string.
+ *   - `"binary"`: Returns the UUID as a `Uint8Array` in binary format.
+ * @param format - The version of the UUID to generate. Can be:
+ *   - `"v4"`: Generates a random UUID (version 4).
+ *   - `"v7"`: Generates a time-ordered UUID (version 7).
+ * @returns The generated UUID in the specified type and format.
+ *   - If `type` is `"text"`, a string representation of the UUID is returned.
+ *   - If `type` is `"binary"`, a `Uint8Array` representation of the UUID is returned.
+ * @throws {Error} If an invalid `type` or `format` is provided.
+ *
+ * @example
+ * // Generate a version 4 UUID as a string
+ * const idTextV4 = generateId("text", "v4");
+ * console.log(idTextV4); // e.g., "550e8400-e29b-41d4-a716-446655440000"
+ *
+ * @example
+ * // Generate a version 7 UUID as binary
+ * const idBinaryV7 = generateId("binary", "v7");
+ * console.log(idBinaryV7); // Uint8Array([...])
+ */
+declare function generateId(type: "text", format: "v4" | "v7"): string;
+declare function generateId(type: "binary", format: "v4" | "v7"): Uint8Array;
 export { generateId };
 //# sourceMappingURL=generateId.d.ts.map

package/dist/generators/generateId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateId.d.ts","sourceRoot":"","sources":["../../src/generators/generateId.ts"],"names":[],"mappings":"AAsBA,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ;;;EAK1C;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"generateId.d.ts","sourceRoot":"","sources":["../../src/generators/generateId.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;AAC/D,iBAAS,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,UAAU,CAAC;AAYrE,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/generators/generateId.js

@@ -1,5 +1,6 @@
 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);
@@ -14,10 +15,15 @@ function uuidV7() {
     const uuid = v7();
     return { text: uuid, binary: hexToBin(uuid) };
 }
-function generateId(type) {
-    return {
-        v4: uuidV4()[type],
-        v7: uuidV7()[type],
-    };
+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.d.ts

@@ -1,3 +1,17 @@
-declare function generateSlug(string: string): string;
+/**
+ * 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 string - The input string to be converted into a slug.
+ * @returns A URL-friendly slug derived from the input string.
+ */
+declare function generateSlug(prop: string): string;
 export { generateSlug };
 //# sourceMappingURL=generateSlug.d.ts.map

package/dist/generators/generateSlug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateSlug.d.ts","sourceRoot":"","sources":["../../src/generators/generateSlug.ts"],"names":[],"mappings":"AAAA,iBAAS,YAAY,CAAC,MAAM,EAAE,MAAM,UAanC;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"generateSlug.d.ts","sourceRoot":"","sources":["../../src/generators/generateSlug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iBAAS,YAAY,CAAC,IAAI,EAAE,MAAM,UAajC;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}