@arkyn/shared 3.0.1-beta.20 → 3.0.1-beta.201

package/README.md

@@ -1,119 +1,394 @@
-The `@arkyn/shared` package provides reusable utilities such as formatting functions, generators, services, and validations. It is designed to be used across different parts of a project, offering common and practical solutions to streamline development.
+# @arkyn/shared
 
----
+Comprehensive collection of reusable utilities for data formatting, validation, generation, and manipulation, featuring Brazilian document validators and financial tools.
 
-## Installation
+[![npm version](https://img.shields.io/npm/v/@arkyn/shared.svg)](https://www.npmjs.com/package/@arkyn/shared)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 
-Install the package using npm:
+## 🎯 What it solves
+
+`@arkyn/shared` is a dependency-light, framework-agnostic toolkit for formatting, validating, generating, and parsing common data types in JavaScript/TypeScript applications. It has strong support for Brazilian documents (CPF, CNPJ, CEP) and locale-aware financial formatting, alongside general-purpose helpers for dates, JSON, strings, IDs, and sensitive-data masking. Because it has no framework assumptions, the same functions run identically on the client and the server — it's the shared foundation used by both `@arkyn/components` and `@arkyn/server`.
+
+## ✨ Features
+
+- 📅 **Date formatting & parsing** — configurable input/output formats with timezone shifting
+- 💰 **Currency & financial formatting** — locale-aware currency strings and card installment math
+- 📝 **Text formatting** — capitalization, ellipsis truncation, digit masking
+- 🇧🇷 **Brazilian document formatting** — CPF, CNPJ, CEP
+- 📞 **Phone formatting** — country-mask-aware phone number formatting via `libphonenumber-js`
+- 🔧 **Generators** — UUID (v4/v7) IDs, URL-friendly slugs, deterministic colors from strings
+- 🧩 **JSON parsers** — pretty-printing, large-field truncation, sensitive-key masking
+- 🛡️ **Sensitive-data masking** — hide digits/fields in strings and JSON payloads
+- 🌐 **HTML utilities** — detect and strip HTML markup
+- 🧹 **String/number utilities** — strip non-numeric characters, strip currency symbols, ensure quoting
+
+## 📋 Prerequisites
+
+- **Node.js** `>=24.16.0`
+- **Bun** `>=1.3.14`
+- **`libphonenumber-js`** `>=1.13.7` — optional peer dependency, required only if you use `formatToPhone` or `findCountryMask`
+
+## 📦 Installation
+
+> **ESM only.** This package ships as native ES modules with no CommonJS build — use `import`, not `require()`.
 
 ```bash
 npm install @arkyn/shared
 ```
 
----
+If you plan to use `formatToPhone` or `findCountryMask`, also install the peer dependency:
+
+```bash
+npm install libphonenumber-js
+```
+
+## 🚀 Quick Start
+
+```typescript
+import {
+  formatToCpf,
+  formatToCurrency,
+  generateId,
+  generateSlug,
+} from "@arkyn/shared";
+
+// Format a raw CPF string (throws if it doesn't have 11 digits)
+const cpf = formatToCpf("12345678909");
+// "123.456.789-09"
+
+// Format currency using a currency code from @arkyn/templates
+const price = formatToCurrency(1234.56, "BRL");
+// "R$ 1.234,56"
+
+// Generate a UUID v4
+const id = generateId("text", "v4");
+// "550e8400-e29b-41d4-a716-446655440000"
+
+// Generate a URL-friendly slug
+const slug = generateSlug("Hello, World! This is a Test.");
+// "hello-world-this-is-a-test"
+```
+
+## 📖 API Reference
+
+### Formats
+
+#### formatDate
+
+Formats a date (and optional time) string into a custom output format. Calculations are done in UTC+0; use the `timezone` parameter to shift the result. Throws `Error` if the resulting date is invalid or `inputFormat` is not recognized.
+
+```typescript
+import { formatDate } from "@arkyn/shared";
+
+formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm");
+// "2023-12-25 15:30"
+
+formatDate(["2023-12-25", "15:30:00"], "timestamp", "DD/MM/YYYY hh:mm", -3);
+// "2023-12-25 12:30"
+```
+
+#### formatJsonObject
+
+Formats a JSON-compatible value (object, array, string, or primitive) into a human-readable, indented string. Strings that parse as JSON are recursively formatted.
+
+```typescript
+import { formatJsonObject } from "@arkyn/shared";
+
+const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
+formatJsonObject(obj, 0);
+// {
+//   "name": "John",
+//   "age": 30,
+//   "hobbies": [
+//     "reading",
+//     "gaming"
+//   ]
+// }
+```
+
+#### formatJsonString
+
+Parses a JSON string and returns a pretty-printed representation. Throws `Error` if the input is not valid JSON.
+
+```typescript
+import { formatJsonString } from "@arkyn/shared";
+
+formatJsonString('{"name":"John","hobbies":["reading","gaming"]}');
+// {
+//   "name": "John",
+//   "hobbies": [
+//     "reading",
+//     "gaming"
+//   ]
+// }
+```
+
+#### formatToCapitalizeFirstWordLetter
 
-## Features
+Capitalizes the first letter of each space-separated word and lowercases the rest.
 
-### Formatting
+```typescript
+import { formatToCapitalizeFirstWordLetter } from "@arkyn/shared";
 
-- **`formatDate(date: dateString[], inputFormat: "brazilianDate" | "isoDate" | "timestamp", outputFormat: string, timezone?: number): string`**  
-  Formats a date into a readable string.
+formatToCapitalizeFirstWordLetter("HELLO WORLD"); // "Hello World"
+```
 
-- **`formatJsonObject(obj: object): string`**  
-  Converts a JSON object into a formatted string.
+#### formatToCep
 
-- **`formatJsonString(json: string): object`**  
-  Converts a JSON string into an object.
+Formats a string into the Brazilian postal code (CEP) pattern `XXXXX-XXX`. Throws `Error` if the cleaned input doesn't contain exactly 8 numeric digits.
 
-- **`formatToCep(value: string): string`**  
-  Formats a string into the CEP format (`XXXXX-XXX`).
+```typescript
+import { formatToCep } from "@arkyn/shared";
+
+formatToCep("12345678"); // "12345-678"
+```
+
+#### formatToCnpj
+
+Formats a string into the CNPJ pattern `XX.XXX.XXX/XXXX-XX`. Throws `Error` if the cleaned input doesn't contain exactly 14 numeric digits.
+
+```typescript
+import { formatToCnpj } from "@arkyn/shared";
+
+formatToCnpj("12345678000195"); // "12.345.678/0001-95"
+```
 
-- **`formatToCnpj(value: string): string`**  
-  Formats a string into the CNPJ format (`XX.XXX.XXX/XXXX-XX`).
+#### formatToCpf
+
+Formats a string into the CPF pattern `XXX.XXX.XXX-XX`. Throws `Error` if the cleaned input doesn't contain exactly 11 numeric digits.
+
+```typescript
+import { formatToCpf } from "@arkyn/shared";
+
+formatToCpf("12345678909"); // "123.456.789-09"
+```
+
+#### formatToCurrency
+
+Formats a number into a locale-aware currency string using `Intl.NumberFormat`, based on a currency code from `@arkyn/templates`. Set `config.showPrefix` to `false` to omit the currency symbol. Throws `Error` for unsupported currency codes.
+
+```typescript
+import { formatToCurrency } from "@arkyn/shared";
+
+formatToCurrency(1234.56, "BRL"); // "R$ 1.234,56"
+formatToCurrency(1234.56, "USD", { showPrefix: false }); // "1,234.56"
+```
+
+#### formatToEllipsis
+
+Truncates a string to `maxLength`, avoiding breaking mid-word, and appends `"..."` if truncation occurred.
+
+```typescript
+import { formatToEllipsis } from "@arkyn/shared";
+
+formatToEllipsis("Hello, world!", 5); // "Hello..."
+```
 
-- **`formatToCpf(value: string): string`**  
-  Formats a string into the CPF format (`XXX.XXX.XXX-XX`).
+#### formatToHiddenDigits
 
-- **`formatToCpfCnpj(value: string): string`**  
-  Formats a string into either CPF or CNPJ format, depending on its length.
+Replaces specific digit positions in a string with a masking character, leaving non-digit characters unchanged. `options.range` can be a positive number (first N digits), a negative number (last N digits), or a `[start, end]` tuple (1-indexed, inclusive). Defaults to hiding the first 3 digits with `"*"`.
 
-- **`formatToCurrency(value: number): string`**  
-  Converts a number into a currency format.
+```typescript
+import { formatToHiddenDigits } from "@arkyn/shared";
 
-  - **`formatToDate(date: dateString[], inputFormat: "brazilianDate" | "isoDate" | "timestamp", timezone?: number): Date`**  
-    Formats a date into a Date class.
+formatToHiddenDigits("123-456-7890", { range: 3 }); // "***-456-7890"
+formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
+// "123-###-7890"
+```
 
-- **`formatToEllipsis(value: string, maxLength: number): string`**  
-  Truncates a string and appends an ellipsis if it exceeds the maximum length.
+#### formatToPhone
 
-- **`formatToHiddenDigits(value: string): string`**  
-  Masks part of a string by replacing it with asterisks.
+Formats a phone number according to the country mask defined in `@arkyn/templates`, parsing it with `libphonenumber-js`. Throws `Error` if the number is invalid or no country mask is found. Requires the `libphonenumber-js` peer dependency.
 
-- **`formatToPhone(value: string): string`**  
-  Formats a string into a phone number format.
+```typescript
+import { formatToPhone } from "@arkyn/shared";
 
----
+formatToPhone("+5534920524282"); // "(34) 92052-4282"
+formatToPhone("+12125550199"); // "(212) 555-0199"
+```
 
 ### Generators
 
-- **`generateColorByString(value: string): string`**  
-  Generates a hexadecimal color based on a string.
+#### generateColorByString
+
+Generates a deterministic hexadecimal color code from a hash of the input string — the same input always produces the same color.
+
+```typescript
+import { generateColorByString } from "@arkyn/shared";
+
+generateColorByString("example"); // "#5e8f9a" (consistent for the same input)
+```
+
+#### generateId
+
+Generates a UUID in the requested version (`"v4"` random or `"v7"` time-ordered) and representation (`"text"` string or `"binary"` `Uint8Array`). Throws `Error` for an invalid type/format combination.
+
+```typescript
+import { generateId } from "@arkyn/shared";
+
+generateId("text", "v4"); // "550e8400-e29b-41d4-a716-446655440000"
+generateId("binary", "v7"); // Uint8Array([...])
+```
+
+#### generateSlug
+
+Converts a string into a URL-friendly slug: strips accents, removes non-alphanumeric characters (except spaces/hyphens), lowercases, replaces spaces with hyphens, and trims/collapses hyphens.
+
+```typescript
+import { generateSlug } from "@arkyn/shared";
+
+generateSlug("Hello, World! This is a Test.");
+// "hello-world-this-is-a-test"
+```
+
+### Parsers
+
+#### parseLargeFields
+
+Parses a JSON string and truncates string fields exceeding `maxLength` (default `1000`), replacing them with a message indicating the original length. Traverses nested objects/arrays. Throws `Error` if the input is not valid JSON.
+
+```typescript
+import { parseLargeFields } from "@arkyn/shared";
+
+const json = JSON.stringify({
+  name: "John",
+  description: "A very long description that exceeds the maximum length...",
+});
+
+parseLargeFields(json, 50);
+// '{"name":"John","description":"To large information: field as 57 characters"}'
+```
+
+#### parseSensitiveData
+
+Parses a JSON string and replaces the values of the given keys with `"****"`, recursively, including JSON-encoded string values. Defaults to masking `password`, `confirmPassword`, and `creditCard`. Returns the original string unchanged if it is not valid JSON (does not throw).
+
+```typescript
+import { parseSensitiveData } from "@arkyn/shared";
+
+const jsonString = JSON.stringify({
+  username: "user123",
+  password: "secret",
+  profile: { creditCard: "1234-5678-9012-3456" },
+});
+
+parseSensitiveData(jsonString, ["password", "creditCard"]);
+// '{"username":"user123","password":"****","profile":{"creditCard":"****"}}'
+```
+
+#### parseToDate
+
+Parses a date (and optional time) string into a `Date` object. Calculations are done in UTC+0; use `timezone` to shift the result. Throws `Error` if the resulting date is invalid or `inputFormat` is not recognized.
 
-- **`generateId(): string`**  
-  Generates a unique identifier.
+```typescript
+import { parseToDate } from "@arkyn/shared";
 
-- **`generateSlug(value: string): string`**  
-  Converts a string into a URL-friendly slug.
+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
+```
 
 ### Services
 
-- **`calculateCardInstallment(total: number, installments: number): number[]`**  
-  Calculates the installment values for a given total.
+#### ValidateDateService
+
+Class used internally by `formatDate` and `parseToDate` to validate date components and input-format strings — enforces 4-digit years, month/day ranges, month-specific day counts, and leap-year rules. `validateDateParts` and `validateInputFormat` both throw `Error` on invalid input.
 
-- **`ensureQuotes(rawValue: string): string`**  
-  Ensures that a given rawValue string is enclosed in quotes.
+```typescript
+import { ValidateDateService } from "@arkyn/shared";
 
-- **`maskSensitiveData(data: string): string`**  
-  Masks sensitive data in a string.
+const service = new ValidateDateService();
+service.validateDateParts(2024, 2, 29); // OK — leap year
+service.validateDateParts(2023, 2, 29); // throws — not a leap year
+service.validateInputFormat("brazilianDate"); // OK
+service.validateInputFormat("custom"); // throws
+```
+
+### Utilities
 
-- **`removeNonNumeric(value: string): string`**  
-  Removes all non-numeric characters from a string.
+#### calculateCardInstallment
 
-- **`truncateLargeFields(obj: object, maxLength: number): object`**  
-  Truncates large fields in an object to a specified maximum length.
+Calculates the total price and per-installment price for a card payment plan with compound interest. No interest is applied when `fees` is `0` or `numberInstallments` is `1`. Throws `Error` if `numberInstallments <= 0` or `fees < 0`.
 
----
+```typescript
+import { calculateCardInstallment } from "@arkyn/shared";
 
-### Validations
+calculateCardInstallment({ cashPrice: 1000, numberInstallments: 12, fees: 0.02 });
+// { totalPrice: 1124.62, installmentPrice: 93.72 }
+```
 
-- **`validateCep(value: string): boolean`**  
-  Validates whether a string is a valid CEP.
+#### ensureQuotes
 
-- **`validateCnpj(value: string): boolean`**  
-  Validates whether a string is a valid CNPJ.
+Wraps a string in double quotes unless it is already enclosed in single or double quotes.
 
-- **`validateCpf(value: string): boolean`**  
-  Validates whether a string is a valid CPF.
+```typescript
+import { ensureQuotes } from "@arkyn/shared";
 
-- **`validateDate(value: string): boolean`**  
-  Validates whether a string is a valid date.
+ensureQuotes("example"); // '"example"'
+ensureQuotes('"already quoted"'); // '"already quoted"'
+```
 
-- **`validatePhone(value: string): boolean`**  
-  Validates whether a string is a valid phone number.
+#### findCountryMask
 
-- **`validateRg(value: string): boolean`**  
-  Validates whether a string is a valid ID (RG).
+Resolves the matching phone mask (using `"_"` as digit placeholders) and country metadata for an E.164 phone number, using `libphonenumber-js` and `@arkyn/templates`. For countries with multiple mask lengths (e.g. Brazil with/without the ninth digit), the mask matching the number's digit count is returned. Throws `Error` if the number is invalid or no mask is found. Requires the `libphonenumber-js` peer dependency.
 
----
+```typescript
+import { findCountryMask } from "@arkyn/shared";
+
+const [mask, country] = findCountryMask("+5511999999999");
+// mask: "(__) _____-____"
+// country.name: "Brazil"
+```
+
+#### isHtml
+
+Checks whether a string contains HTML markup (opening or closing tags), case-insensitively.
+
+```typescript
+import { isHtml } from "@arkyn/shared";
+
+isHtml("<p>Hello world</p>"); // true
+isHtml("Plain text"); // false
+```
 
-## Contribution
+#### removeCurrencySymbols
+
+Removes currency symbols (`R$`, `$`, `€`, `¥`, `£`, and other Unicode currency symbols) from a string and trims whitespace.
+
+```typescript
+import { removeCurrencySymbols } from "@arkyn/shared";
+
+removeCurrencySymbols("R$13,45"); // "13,45"
+removeCurrencySymbols("€99.99"); // "99.99"
+```
+
+#### removeNonNumeric
+
+Strips all non-numeric characters from a string.
+
+```typescript
+import { removeNonNumeric } from "@arkyn/shared";
+
+removeNonNumeric("abc123def456"); // "123456"
+```
+
+#### stripHtmlTags
+
+Removes HTML tags from a string, including `<script>` and `<style>` blocks and HTML comments.
+
+```typescript
+import { stripHtmlTags } from "@arkyn/shared";
+
+stripHtmlTags("<p>Hello <strong>World</strong></p>"); // "Hello World"
+```
 
-Contributions are welcome! Feel free to open issues or submit pull requests to improve the project.
+## 📚 Documentation
 
----
+Full documentation: [https://docs.arkyn.dev/docs/shared/introduction](https://docs.arkyn.dev/docs/shared/introduction)
 
-## License
+## 📄 License
 
-This project is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.
+This project is licensed under the Apache 2.0 License - see the [LICENSE](./LICENSE.txt) file for details.

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"}