@arkyn/shared 3.0.1-beta.99 → 3.0.3

package/dist/formats/formatDate.d.ts

@@ -1,34 +1,26 @@
-type InputFormatTypes = "brazilianDate" | "isoDate" | "timestamp";
-type FormatDateFunction = (date: string[], // [date: string, time?: string]
-inputFormat: InputFormatTypes, outputFormat: string, timezone?: number) => string;
 /**
- * Formats a date and time string based on the provided input and output formats.
+ * Formats a date (and optional time) string into a custom output format.
+ * All calculations are in UTC+0; use the `timezone` parameter to shift the result.
  *
- * @param {[string, string]} dateTime - An array containing the date and optional time.
- *   - The first element is the date string.
- *   - The second element is the time string (default is "00:00:00").
- * @param {"brazilianDate" | "isoDate" | "timestamp"} inputFormat - The format of the input date.
- *   - "brazilianDate": Expects the date in "DD/MM/YYYY" format.
- *   - "isoDate": Expects the date in "YYYY-MM-DD" format.
- *   - "timestamp": Expects the date in "YYYY/MM/DD" format.
- * @param {string} outputFormat - The desired output format for the date.
- *   - Use placeholders like "YYYY", "MM", "DD", "hh", "mm", "ss" to define the format.
- * @param {number} [timezone=0] - The timezone offset in hours to apply to the date.
- *   - Defaults to 0 (UTC).
- * @returns {string} The formatted date string based on the output format.
- * @throws {Error} If the input format is invalid.
- * @throws {Error} If the date is invalid.
+ * @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 outputFormat - Output template using `YYYY`, `MM`, `DD`, `hh`, `mm`, `ss` placeholders.
+ * @param timezone - UTC offset in hours (e.g. `-3` for UTC-3). Defaults to `0`.
+ * @returns The formatted date string.
  *
  * @example
- * // Format a Brazilian date to ISO format
- * formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm:ss");
- * // Returns: "2023-12-25 15:30:00"
+ * ```typescript
+ * formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm");
+ * // "2023-12-25 15:30"
  *
- * @example
- * // Format an ISO date to a custom format with timezone adjustment
- * formatDate(["2023-12-25", "15:30:00"], "isoDate", "DD/MM/YYYY hh:mm:ss", -3);
- * // Returns: "25/12/2023 12:30:00"
+ * formatDate(["2023-12-25", "15:30:00"], "timestamp", "DD/MM/YYYY hh:mm", -3);
+ * // "2023-12-25 12:30"
+ * ```
  */
-declare const formatDate: FormatDateFunction;
+declare function formatDate([date, time]: string[], inputFormat: "brazilianDate" | "isoDate" | "timestamp", outputFormat: string, timezone?: number): string;
 export { formatDate };
 //# sourceMappingURL=formatDate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatDate.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;AAElE,KAAK,kBAAkB,GAAG,CACxB,IAAI,EAAE,MAAM,EAAE,EAAE,gCAAgC;AAChD,WAAW,EAAE,gBAAgB,EAC7B,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC;AAqBZ;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAgCjB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/formats/formatDate.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,iBAAS,UAAU,CAClB,CAAC,IAAI,EAAE,IAAiB,CAAC,EAAE,MAAM,EAAE,EACnC,WAAW,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,EACtD,YAAY,EAAE,MAAM,EACpB,QAAQ,GAAE,MAAU,GAClB,MAAM,CAkCR;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/formats/formatJsonObject.d.ts

@@ -1,17 +1,15 @@
-type FormatJsonObjectFunction = (jsonString: any, identLevel: number) => string;
 /**
  * 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.
  *
+ * @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"] };
@@ -28,6 +26,6 @@ type FormatJsonObjectFunction = (jsonString: any, identLevel: number) => string;
  * // }
  * ```
  */
-declare const formatJsonObject: FormatJsonObjectFunction;
+declare const formatJsonObject: (json: any, indentLevel: number) => string;
 export { formatJsonObject };
 //# sourceMappingURL=formatJsonObject.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatJsonObject.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonObject.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,CAAC,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAuDvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatJsonObject.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,QAAA,MAAM,gBAAgB,GAAI,MAAM,GAAG,EAAE,aAAa,MAAM,KAAG,MAsD1D,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatJsonString.d.ts

@@ -1,37 +1,21 @@
 type FormatJsonStringFunction = (jsonString: string) => string;
 /**
- * Formats a JSON string into a more readable format.
+ * Parses a JSON string and returns a human-readable pretty-printed representation.
+ * Throws if the input is not valid JSON.
  *
- * This function attempts to parse the provided JSON string into a JavaScript object,
- * and then formats it using the `formatJsonObject` function. If the input string
- * is not a valid JSON, it logs an error to the console and returns an empty string.
- *
- * @param jsonString - The JSON string to be formatted.
- * @returns A formatted JSON string, or an empty string if the input is invalid.
- *
- * @throws Will log an error to the console if the input is not a valid JSON string.
+ * @param jsonString - A valid JSON string to format.
+ * @returns A pretty-printed string representation.
  *
  * @example
  * ```typescript
- * const jsonString = '{"name":"John","age":30,"hobbies":["reading","gaming"]}';
- * const formatted = formatJsonString(jsonString);
- * console.log(formatted);
- * // Output:
+ * formatJsonString('{"name":"John","hobbies":["reading","gaming"]}');
  * // {
  * //   "name": "John",
- * //   "age": 30,
  * //   "hobbies": [
  * //     "reading",
  * //     "gaming"
  * //   ]
  * // }
-
- * const invalidJsonString = '{"name":"John", "age":30,';
- * const formatted = formatJsonString(invalidJsonString);
- * console.log(formatted);
- * // Output:
- * // (Logs "Invalid JSON string: ..." to the console)
- * // ""
  * ```
  */
 declare const formatJsonString: FormatJsonStringFunction;

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

@@ -1 +1 @@
-{"version":3,"file":"formatJsonString.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonString.ts"],"names":[],"mappings":"AAEA,KAAK,wBAAwB,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatJsonString.d.ts","sourceRoot":"","sources":["../../src/formats/formatJsonString.ts"],"names":[],"mappings":"AAEA,KAAK,wBAAwB,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToCapitalizeFirstWordLetter.d.ts

@@ -1,33 +1,14 @@
 /**
- * Formats a sentence by capitalizing the first letter of each word.
- *
- * This function takes a string and capitalizes the first letter of each word
- * while the remaining letters are lowercase.
+ * Capitalizes the first letter of each word and lowercases the rest.
  * Words are separated by spaces.
  *
- * @param sentence - The sentence to be formatted.
- * @returns The sentence formatted with the first letter of each word capitalized.
+ * @param sentence - The string to format.
+ * @returns The sentence with every word title-cased.
  *
  * @example
  * ```typescript
- * // Basic example
- * formatToCapitalizeFirstWordLetter("hello world");
- * // Returns: "Hello World"
- *
- * // With capitalized text.
- * formatToCapitalizeFirstWordLetter("HELLO WORLD");
- * // Returns: "Hello World"
- *
- * // With mixed text.
- * formatToCapitalizeFirstWordLetter("hELLO WoRLd"); * // Returns: "Hello World"
- *
- * // With multiple words
- * formatToCapitalizeFirstWordLetter("javascript is an amazing language");
- * // Returns: "Javascript is an amazing language"
- *
- * // Empty string
- * formatToCapitalizeFirstWordLetter("");
- * // Returns: ""
+ * formatToCapitalizeFirstWordLetter("hello world");  // "Hello World"
+ * formatToCapitalizeFirstWordLetter("HELLO WORLD");  // "Hello World"
  * ```
  */
 declare function formatToCapitalizeFirstWordLetter(sentence: string): string;

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

@@ -1 +1 @@
-{"version":3,"file":"formatToCapitalizeFirstWordLetter.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCapitalizeFirstWordLetter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,iBAAS,iCAAiC,CAAC,QAAQ,EAAE,MAAM,UAU1D;AAED,OAAO,EAAE,iCAAiC,EAAE,CAAC"}
+{"version":3,"file":"formatToCapitalizeFirstWordLetter.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCapitalizeFirstWordLetter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,iBAAS,iCAAiC,CAAC,QAAQ,EAAE,MAAM,UAU1D;AAED,OAAO,EAAE,iCAAiC,EAAE,CAAC"}

package/dist/formats/formatToCep.d.ts

@@ -1,4 +1,3 @@
-type FormatToCepFunction = (value: string) => string;
 /**
  * Formats a given string into a Brazilian postal code (CEP) format.
  *
@@ -6,24 +5,17 @@ type FormatToCepFunction = (value: string) => 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 - The input string to be formatted as a CEP.
+ * @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
- * import { formatToCep } from "./formatToCep";
- *
  * const formattedCep = formatToCep("12345678");
  * console.log(formattedCep); // Output: "12345-678"
- *
- * try {
- *   formatToCep("1234");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CEP format"
- * }
  * ```
  */
-declare const formatToCep: FormatToCepFunction;
+declare function formatToCep(value: string): string;
 export { formatToCep };
 //# sourceMappingURL=formatToCep.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToCep.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCep.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"formatToCep.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCnpj.d.ts

@@ -1,30 +1,19 @@
-type FormatToCnpjFunction = (value: string) => string;
 /**
  * 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 - The input value to be formatted. It can be a string or number containing the CNPJ digits.
- *                Non-numeric characters will be removed before formatting.
- *
- * @returns A string formatted as a CNPJ.
+ * @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
- * import { formatToCnpj } from "./formatToCNPJ";
- *
  * const formattedCnpj = formatToCnpj("12345678000195");
  * console.log(formattedCnpj); // Output: "12.345.678/0001-95"
- *
- * try {
- *   formatToCnpj("12345");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CNPJ length"
- * }
  * ```
  */
-declare const formatToCnpj: FormatToCnpjFunction;
+declare function formatToCnpj(value: string): string;
 export { formatToCnpj };
 //# sourceMappingURL=formatToCnpj.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCnpj.ts"],"names":[],"mappings":"AAEA,KAAK,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAMnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"formatToCnpj.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCnpj.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,iBAAS,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/formats/formatToCpf.d.ts

@@ -1,4 +1,3 @@
-type FormatToCpfFunction = (value: string) => string;
 /**
  * Formats a given string into a CPF (Cadastro de Pessoas Físicas) format.
  *
@@ -6,25 +5,17 @@ type FormatToCpfFunction = (value: string) => string;
  * 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 - The input string to be formatted as a CPF.
- * @returns The formatted CPF string.
+ * @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
- * import { formatToCpf } from "./formatToCPF";
- *
  * const formattedCpf = formatToCpf("12345678909");
  * console.log(formattedCpf); // Output: "123.456.789-09"
-
- * try {
- *   const formattedCpf = formatToCpf("12345");
- * } catch (error) {
- *   console.error(error.message); // Output: "Invalid CPF format"
- * }
- *
  * ```
  */
-declare const formatToCpf: FormatToCpfFunction;
+declare function formatToCpf(value: string): string;
 export { formatToCpf };
 //# sourceMappingURL=formatToCpf.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToCpf.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpf.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAMlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"formatToCpf.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCpf.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/formats/formatToCurrency.d.ts

@@ -1,34 +1,21 @@
 import { countryCurrencies } from "@arkyn/templates";
 type Currencies = keyof typeof countryCurrencies;
-type Config = {
-    showPrefix?: boolean;
-};
-type FormatToCurrency = (value: number, currency: Currencies, config?: Config) => string;
 /**
- * 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`.
+ * Formats a number into a locale-aware currency string using `Intl.NumberFormat`.
  *
- * @returns A formatted currency string. If `config.showPrefix` is `false`, the currency symbol is removed.
+ * @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
- * 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"
+ * formatToCurrency(1234.56, "BRL"); // "R$ 1.234,56"
+ * formatToCurrency(1234.56, "USD", { showPrefix: false }); // "1,234.56"
  * ```
  */
-declare const formatToCurrency: FormatToCurrency;
+declare function formatToCurrency(value: number, currency: Currencies, config?: {
+    showPrefix?: boolean;
+}): string;
 export { formatToCurrency };
 //# sourceMappingURL=formatToCurrency.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatToCurrency.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,KAAK,UAAU,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAEjD,KAAK,MAAM,GAAG;IACZ,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,KAAK,gBAAgB,GAAG,CACtB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE,MAAM,KACZ,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,gBAmBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatToCurrency.d.ts","sourceRoot":"","sources":["../../src/formats/formatToCurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,KAAK,UAAU,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,iBAAS,gBAAgB,CACxB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/B,MAAM,CAiBR;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToEllipsis.d.ts

@@ -1,16 +1,16 @@
-type FormatToEllipsisFunction = (value: string, maxLength: number) => string;
 /**
  * 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.
+ * @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..."
+ * ```
  */
-declare const formatToEllipsis: FormatToEllipsisFunction;
+declare function formatToEllipsis(text: string, maxLength: number): string;
 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,KAAK,wBAAwB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;AAE7E;;;;;;;;;;;GAWG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAOvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"formatToEllipsis.d.ts","sourceRoot":"","sources":["../../src/formats/formatToEllipsis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAsBjE;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/formats/formatToHiddenDigits.d.ts

@@ -1,35 +1,24 @@
-type FormatToHiddenDigitsFunction = (value: string, options: {
-    range?: number | [number, number];
-    hider?: string;
-}) => string;
 /**
- * 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 `"*"`.
+ * Replaces specific digits in a string with a masking character, leaving non-digit characters unchanged.
  *
- * @returns The formatted string with specified digits hidden.
+ * @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
- * import { formatToHiddenDigits } from "./formatToHiddenDigits";
- *
- * formatToHiddenDigits("123-456-7890", { range: 3 });
- * // Output: "***-456-7890"
- *
- * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
- * // Output: "123-###-7890"
+ * formatToHiddenDigits("123-456-7890", { range: 3 });         // "***-456-7890"
+ * formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" }); // "123-###-7890"
  * ```
  */
-declare const formatToHiddenDigits: FormatToHiddenDigitsFunction;
+declare function formatToHiddenDigits(value: string, options?: {
+    range?: number | [number, number];
+    hider?: string;
+}): string;
 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":"AAmBA,KAAK,4BAA4B,GAAG,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAC3D,MAAM,CAAC;AA4BZ;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,QAAA,MAAM,oBAAoB,EAAE,4BAU3B,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"formatToHiddenDigits.d.ts","sourceRoot":"","sources":["../../src/formats/formatToHiddenDigits.ts"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,oBAAoB,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7D,MAAM,CAWR;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/formats/formatToPhone.d.ts

@@ -1,34 +1,22 @@
-type FormatToPhoneFunction = (prop: string) => string;
 /**
- * Formats a phone number string based on the provided country code and optional prefix.
+ * Formats a phone number string according to the country mask defined in `@arkyn/templates`.
  *
- * 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.
+ * 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 prop - The phone number string to be formatted. It must include the country code and optionally a prefix.
- *               Example formats:
- *               - "+55 32912345678"
- *               - "+1 1234567890"
+ * @param phoneNumber - The input phone number in E.164 format (e.g. `"+5534920524282"`).
+ * @returns The phone number formatted according to the country's mask.
  *
- * @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.
+ * @throws {Error} If the phone number is invalid or if no country mask is found for the parsed country.
  *
  * @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)
+ * 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)
  * ```
  */
-declare const formatToPhone: FormatToPhoneFunction;
+declare function formatToPhone(phoneNumber: string): string;
 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,KAAK,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AAmGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAwBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"formatToPhone.d.ts","sourceRoot":"","sources":["../../src/formats/formatToPhone.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,iBAAS,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CA0BlD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/generators/generateColorByString.d.ts

@@ -1,15 +1,17 @@
-type GenerateColorByStringFunction = (prop: string) => 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.
+ * @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"
+ * ```
  */
-declare const generateColorByString: GenerateColorByStringFunction;
+declare function generateColorByString(rawString: string): string;
 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,KAAK,6BAA6B,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AAE9D;;;;;;;;;;GAUG;AAEH,QAAA,MAAM,qBAAqB,EAAE,6BAgB5B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"generateColorByString.d.ts","sourceRoot":"","sources":["../../src/generators/generateColorByString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iBAAS,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAgBxD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/generators/generateId.d.ts

@@ -1,26 +1,15 @@
 /**
- * Generates a unique identifier (UUID) in the specified format and type.
+ * Generates a UUID in the specified version and output 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.
+ * @param type - Output representation: `"text"` (string) or `"binary"` (`Uint8Array`).
+ * @param format - UUID version: `"v4"` (random) or `"v7"` (time-ordered).
+ * @returns The UUID as a string or `Uint8Array` depending on `type`.
  *
  * @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([...])
+ * ```typescript
+ * generateId("text", "v4");   // "550e8400-e29b-41d4-a716-446655440000"
+ * generateId("binary", "v7"); // Uint8Array([...])
+ * ```
  */
 declare function generateId(type: "text", format: "v4" | "v7"): string;
 declare function generateId(type: "binary", format: "v4" | "v7"): Uint8Array;

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"generateId.d.ts","sourceRoot":"","sources":["../../src/generators/generateId.ts"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;GAYG;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/generateSlug.d.ts

@@ -9,9 +9,15 @@
  * - Collapses multiple consecutive hyphens into a single hyphen.
  * - Trims leading and trailing hyphens.
  *
- * @param string - The input string to be converted into a slug.
+ * @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"
+ * ```
  */
-declare function generateSlug(prop: string): string;
+declare function generateSlug(rawString: 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;;;;;;;;;;;;;GAaG;AAEH,iBAAS,YAAY,CAAC,IAAI,EAAE,MAAM,UAajC;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"generateSlug.d.ts","sourceRoot":"","sources":["../../src/generators/generateSlug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,iBAAS,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAa/C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}