bguard 0.1.0 → 0.1.1

package/README.md

@@ -78,10 +78,8 @@ type StudentSchema = {
 
 ```
 
-
 #### Generating TypeScript Types with `codeGen`
 
-
 If you prefer to generate TypeScript types as a string, you can use the `codeGen` function:
 
 ```typeScript
@@ -112,6 +110,7 @@ This would output a string:
   verified?: boolean | undefined;
 }
 ```
+
 Note: The returned string does not include a type name or the `=` symbol. You would need to add these manually if you want a complete type definition.
 
 #### Generating Named TypeScript Types with `codeGenWithName`
@@ -133,7 +132,6 @@ console.log(namedTypeString);
 
 This would output a string:
 
-
 ```typeScript
 type StudentSchema = {
   email?: string | undefined;
@@ -147,13 +145,13 @@ type StudentSchema = {
   verified?: boolean | undefined;
 }
 ```
+
 #### Summary:
 
 `codeGen(schema: CommonSchema): string` - Generates a string of the TypeScript type based on the schema. You need to manually add a type name and assignment if needed.
 
 `codeGenWithName(typeName: string, schema: CommonSchema): string` - Generates a complete TypeScript type definition string, including the type keyword and type name.
 
-
 ### Validating Data
 
 This library provides two methods to parse data against schemas: `parse` and `parseOrFail`. These methods help in validating the data and obtaining structured errors if any issues are found during validation.
@@ -188,15 +186,12 @@ const invalidStudentData = {
   ],
   email: 'invalid-example',
 };
-
 ```
 
-
 #### `parse` Method
 
 The `parse` method validates the data and returns a tuple containing errors and the parsed value. This method allows you to choose whether to collect all errors or stop at the first error using an options flag.
 
-
 **Syntax:**
 
 ```typescript
@@ -235,16 +230,18 @@ try {
   console.error(error.message); // Logs the first validation error message, if any
 }
 ```
+
 Throws:
+
 - `ValidationError`: If any validation rule fails, this error is thrown with details of the first encountered error.
 
 Options:
-- `lng`: Specifies the language for error messages. Default is `'default'`.
 
+- `lng`: Specifies the language for error messages. Default is `'default'`.
 
 ####
 
-### Explanation
+Explanation
 
 - **`parse` Method**: This method returns a tuple where the first element is an array of validation errors (if any), and the second element is the successfully parsed value (or `undefined` if errors exist). It allows collecting all errors by setting the `getAllErrors` flag.
 
@@ -276,9 +273,12 @@ const schema = string().nullable().optional();
   `boolean().onlyTrue()` will infer <b>true</b> as the type.
   `boolean().onlyFalse()` will infer <b>false</b> as the type.
 
-### Custom Assertions
+### Custom (Library Built-in) Assertions
+
+The `custom` method allows you to extend the validation schema with additional asserts. These asserts can either be user-defined or selected from the comprehensive set provided by the library. This flexibility ensures that you can tailor validations to meet specific requirements beyond the standard methods available.
+All built-in asserts are documented in the [Built-in Custom Assert Documentation](#builtin_custom_assert_documentation) section.
 
-You can extend the validation with custom assertions:
+Example
 
 ```typeScript
 import { min } from 'bguard/number/min';
@@ -287,10 +287,53 @@ import { max } from 'bguard/number/max';
 const ageSchema = number().custom(min(18), max(120));
 ```
 
-Assertions are imported from specific paths for better tree-shaking and smaller bundle sizes.
+Library built-in assertions are imported from specific paths for better tree-shaking and smaller bundle sizes.
+
+### Create Custom Assertions
+
+Bguard allows developers to create custom validation functions that can be integrated seamlessly with the library's existing functionality. Below is a detailed example demonstrating how to create a custom validation function, `minLength`, and how to properly document and map error messages for translations.
+
+Example: Creating a `minLength` Custom Validation
+
+```typescript
+import { guardException } from 'bguard/exceptions';
+import { ExceptionContext, RequiredValidation } from 'bguard/commonTypes';
+import { setToDefaultLocale } from 'bguard/translationMap';
+
+const minLengthErrorMessage = 'The received value {{r}} is shorter than the expected length {{e}}';
+const minLengthErrorKey = 'customPrefix:minLength';
+
+export const minLength =
+  (expected: number): RequiredValidation =>
+  (received: string, ctx: ExceptionContext) => {
+    if (received.length < expected) {
+      guardException(expected, received, ctx, minLengthErrorKey);
+    }
+  };
+
+minLength.key = minLengthErrorKey;
+minLength.message = minLengthErrorMessage;
+setToDefaultLocale(minLength);
+```
+
+Explanation
+
+- Error Key (`minLength.key`): This key (`'customPrefix:minLength'`) uniquely identifies the validation and is used for mapping error messages, especially when supporting multiple languages. It's essential to avoid collisions with built-in assertions, which use prefixes like `s:`, `n:`, and `b:` etc. More on that in [Common and Custom Translations](#common_and_custom_translations).
+
+- Error Message (`minLength.message`): The message supports [interpolation](#translation), where `{{e}}` will be replaced by the expected value, and `{{r}}` will be replaced by the received value during validation .
+
+- Exception Handling (`guardException`): This function is responsible for throwing the error when the validation fails. The `ctx` parameter must be passed to ensure the internal logic of the application works correctly.
+
+- Localization Support (`setToDefaultLocale`): This function registers the default error message with its associated key. If you later decide to support multiple languages, you can easily map this key to different messages.
 
+- Key Points for Developers:
 
-### Translation
+  1. Always create unique error keys for custom validations to avoid potential conflicts with Bguard's built-in validations.
+  2. Custom validations should use prefixes other than `s:`, `n:`, `b:`, and similar ones reserved for Bguard's internal validations.
+  3. The `minLengthErrorMessage` serves as the default message. If you want to provide translations, you can do so by mapping the error key in the translationMap.
+     For single-language applications, you can override the default message by directly passing your custom message to `guardException`.
+
+### Translation {#translation}
 
 Bguard provides default translations for error messages, but you can customize them as needed. Each potential error has an `errorKey` and `errorMessage`.
 
@@ -319,19 +362,17 @@ setLocale('SR', {
   // ... continue adding other translations
 });
 ```
+
 With this setup, in the translation namespace 'SR', if the received value is 4, you'll get an error message like:
 
 `'The received value 4 found on path .foo is less than expected value 5'`
 
- - `{{r}}` - Replaced with the received value.
- - `{{p}}` - Replaced with the path to the error.
- - `{{e}}` - Replaced with the expected value.
-
+- `{{r}}` - Replaced with the received value.
+- `{{p}}` - Replaced with the path to the error.
+- `{{e}}` - Replaced with the expected value.
 
 > **Notice:** Do not overwrite the 'default' namespace. If a translation is missing, it will fall back to the 'default' translation.
 
-
-
 #### Using Translations
 
 To apply the new translation, both `parse` and `parseOrFail` functions accept a lng property in the options object provided as the third parameter:
@@ -342,8 +383,7 @@ parseOrFail(testSchema, { foo: 4 }, { lng: 'SR' });
 parse(testSchema, { foo: 4 }, { lng: 'SR' });
 ```
 
-
-#### Common and Custom Translations
+#### Common and Custom Translations {#common_and_custom_translations}
 
 We have two sets of translations: common errors and specific assertions.
 
@@ -365,7 +405,7 @@ We have two sets of translations: common errors and specific assertions.
 
 For custom assertions, each key and message are located in separate files for better code splitting. There are multiple ways to identify a key:
 
-1. Key Construction:
+<b>1.</b> Key Construction:
 Keys are constructed as `'{typeId}:{functionName}'`, where `typeId` represents:
 
 - c - common
@@ -386,9 +426,10 @@ Example:
 ```typeScript
 import { maxLength } from 'bguard/string/maxLength';
 ```
+
 The function located in `'bguard/string/maxLength'` will have the key `'s:maxLength'`.
 
-2. Assertion Function Properties:
+<b>2.</b> Assertion Function Properties:
 
 Each assert function has two additional properties: `key` and `message`.
 
@@ -398,10 +439,12 @@ import { maxLength } from 'bguard/string/maxLength';
 console.log(maxLength.key); // Output: 's:maxLength'
 console.log(maxLength.message); // Output: 'The received value length is greater than expected'
 ```
+
 > **Notice:** Do not directly change these values.
 
-3. IDE Support:
-Each key and message will be visible in text editors that support JSDoc IntelliSense.### Custom Assert Documentation 
+<b>3.</b> IDE Support:
+Each key and message will be visible in text editors that support JSDoc IntelliSense.
+### Built-in Custom Assert Documentation {#builtin_custom_assert_documentation} 
 
 #### mix
         
@@ -558,6 +601,97 @@ import { positive } from 'bguard/number/positive';
         
 #### string
         
+##### atLeastOneDigit (string)
+        
+```typescript
+import { atLeastOneDigit } from 'bguard/string/atLeastOneDigit';
+```
+        
+* _Description_ Asserts that a string value contains at least one digit.
+* _Throws_ {ValidationError} if the received value does not contain at least one digit.
+* _Example_
+```typescript
+ const schema = string().custom(atLeastOneDigit());
+ parseOrFail(schema, 'abc123'); // Valid
+ parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one digit'
+```
+* _See_ Error Translation Key = 's:atLeastOneDigit'
+        
+        
+##### atLeastOneLowerChar (string)
+        
+```typescript
+import { atLeastOneLowerChar } from 'bguard/string/atLeastOneLowerChar';
+```
+        
+* _Description_ Asserts that a string value contains at least one lowercase character.
+* _Throws_ {ValidationError} if the received value does not contain at least one lowercase character.
+* _Example_
+```typescript
+ const schema = string().custom(atLeastOneLowerChar());
+ parseOrFail(schema, 'abcDEF'); // Valid
+ parseOrFail(schema, 'ABCDEF'); // Throws an error: 'The received value does not contain at least one lowercase character'
+```
+* _See_ Error Translation Key = 's:atLeastOneLowerChar'
+        
+        
+##### atLeastOneSpecialChar (string)
+        
+```typescript
+import { atLeastOneSpecialChar } from 'bguard/string/atLeastOneSpecialChar';
+```
+        
+* _Description_ Asserts that a string value contains at least one special character.
+* _Param_ {string} [allowedSpecialChars=* '@!#%&()^~{}'] The string containing allowed special characters. Defaults to '*@!#%&()^~{}'.
+* _Throws_ {ValidationError} if the received value does not contain at least one of the allowed special characters.
+* _Example_
+```typescript
+ const schema = string().custom(atLeastOneSpecialChar()); // Default special characters
+ parseOrFail(schema, 'abc!def'); // Valid
+ parseOrFail(schema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'
+
+ const customSchema = string().custom(atLeastOneSpecialChar('@$')); // Custom special characters
+ parseOrFail(customSchema, 'abc@def'); // Valid
+ parseOrFail(customSchema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'
+```
+* _See_ Error Translation Key = 's:atLeastOneSpecialChar'
+        
+        
+##### atLeastOneUpperChar (string)
+        
+```typescript
+import { atLeastOneUpperChar } from 'bguard/string/atLeastOneUpperChar';
+```
+        
+* _Description_ Asserts that a string value contains at least one uppercase character.
+* _Throws_ {ValidationError} if the received value does not contain at least one uppercase character.
+* _Example_
+```typescript
+ const schema = string().custom(atLeastOneUpperChar());
+ parseOrFail(schema, 'abcDEF'); // Valid
+ parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one uppercase character'
+```
+* _See_ Error Translation Key = 's:atLeastOneUpperChar'
+        
+        
+##### contains (string)
+        
+```typescript
+import { contains } from 'bguard/string/contains';
+```
+        
+* _Description_ Asserts that a string value contains a specified substring.
+* _Param_ {string} substring The substring that must be present in the string value.
+* _Throws_ {ValidationError} if the received value does not contain the required substring.
+* _Example_
+```typescript
+ const schema = string().custom(contains('foo'));
+ parseOrFail(schema, 'foobar'); // Valid
+ parseOrFail(schema, 'bar'); // Throws an error: 'The received value does not contain the required substring'
+```
+* _See_ Error Translation Key = 's:contains'
+        
+        
 ##### email (string)
         
 ```typescript
@@ -575,6 +709,41 @@ import { email } from 'bguard/string/email';
 * _See_ - Error Translation Key = 's:email'
         
         
+##### endsWith (string)
+        
+```typescript
+import { endsWith } from 'bguard/string/endsWith';
+```
+        
+* _Description_ Asserts that a string value ends with a specified substring.
+* _Param_ {string} substring The substring that the string value must end with.
+* _Throws_ {ValidationError} if the received value does not end with the required substring.
+* _Example_
+```typescript
+ const schema = string().custom(endsWith('bar'));
+ parseOrFail(schema, 'foobar'); // Valid
+ parseOrFail(schema, 'foofoo'); // Throws an error: 'The received value does not end with the required substring'
+```
+* _See_ Error Translation Key = 's:endsWith'
+        
+        
+##### lowerCase (string)
+        
+```typescript
+import { lowerCase } from 'bguard/string/lowerCase';
+```
+        
+* _Description_ Asserts that a string value is in lowercase.
+* _Throws_ {ValidationError} if the received value is not in lowercase.
+* _Example_
+```typescript
+ const schema = string().custom(lowerCase());
+ parseOrFail(schema, 'valid');   // Valid
+ parseOrFail(schema, 'Invalid'); // Throws an error: 'The received value is not in lowercase'
+```
+* _See_ Error Translation Key = 's:lowerCase'
+        
+        
 ##### maxLength (string)
         
 ```typescript
@@ -628,5 +797,170 @@ import { regExp } from 'bguard/string/regExp';
 ```
 * _See_ Error Translation Key = 's:regExp'
         
+        
+##### startsWith (string)
+        
+```typescript
+import { startsWith } from 'bguard/string/startsWith';
+```
+        
+* _Description_ Asserts that a string value starts with a specified substring.
+* _Param_ {string} substring The substring that the string value must start with.
+* _Throws_ {ValidationError} if the received value does not start with the required substring.
+* _Example_
+```typescript
+ const schema = string().custom(startsWith('foo'));
+ parseOrFail(schema, 'foobar'); // Valid
+ parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'
+```
+* _See_ Error Translation Key = 's:startsWith'
+        
+        
+##### upperCase (string)
+        
+```typescript
+import { upperCase } from 'bguard/string/upperCase';
+```
+        
+* _Description_ Asserts that a string value is entirely in uppercase.
+* _Throws_ {ValidationError} if the received value is not in uppercase.
+* _Example_
+```typescript
+ const schema = string().custom(upperCase());
+ parseOrFail(schema, 'VALID');    // Valid
+ parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'
+ parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'
+```
+* _See_ Error Translation Key = 's:upperCase'
+        
+        
+##### uuid (string)
+        
+```typescript
+import { uuid } from 'bguard/string/uuid';
+```
+        
+* _Description_ Asserts that a string value matches the UUID format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID.
+* _Example_
+```typescript
+ const schema = string().custom(uuid());
+ parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'
+```
+* _See_ Error Translation Key = 's:uuid'
+        
+        
+##### uuidV1 (string)
+        
+```typescript
+import { uuidV1 } from 'bguard/string/uuidV1';
+```
+        
+* _Description_ Asserts that a string value matches the UUID v1 format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID v1.
+* _Example_
+```typescript
+ const schema = string().custom(uuidV1());
+ parseOrFail(schema, '550e8400-e29b-11d4-a716-446655440000'); // Valid
+ parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v1'
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v1'
+```
+* _See_ Error Translation Key = 's:uuidV1'
+        
+        
+##### uuidV2 (string)
+        
+```typescript
+import { uuidV2 } from 'bguard/string/uuidV2';
+```
+        
+* _Description_ Asserts that a string value matches the UUID v2 format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID v2.
+* _Example_
+```typescript
+ const schema = string().custom(uuidV2());
+ parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Valid
+ parseOrFail(schema, '550e8400-e29b-31d4-d716-446655440000'); // Throws an error: 'The received value is not a valid UUID v2'
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v2'
+```
+* _See_ Error Translation Key = 's:uuidV2'
+        
+        
+##### uuidV3 (string)
+        
+```typescript
+import { uuidV3 } from 'bguard/string/uuidV3';
+```
+        
+* _Description_ Asserts that a string value matches the UUID v3 format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID v3.
+* _Example_
+```typescript
+ const schema = string().custom(uuidV3());
+ parseOrFail(schema, '550e8400-e29b-38d1-a456-426614174000'); // Valid
+ parseOrFail(schema, '550e8400-e29b-28d1-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v3'
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v3'
+```
+* _See_ Error Translation Key = 's:uuidV3'
+        
+        
+##### uuidV4 (string)
+        
+```typescript
+import { uuidV4 } from 'bguard/string/uuidV4';
+```
+        
+* _Description_ Asserts that a string value matches the UUID v4 format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID v4.
+* _Example_
+```typescript
+ const schema = string().custom(uuidV4());
+ parseOrFail(schema, '123e4567-e89b-42d3-a456-426614174000'); // Valid
+ parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'
+ parseOrFail(schema, '123e4567-e89b-a2d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'
+ parseOrFail(schema, '123e4567-e89b-42d3-c456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v4'
+```
+* _See_ Error Translation Key = 's:uuidV4'
+        
+        
+##### uuidV5 (string)
+        
+```typescript
+import { uuidV5 } from 'bguard/string/uuidV5';
+```
+        
+* _Description_ Asserts that a string value matches the UUID v5 format.
+* _Throws_ {ValidationError} if the received value is not a valid UUID v5.
+* _Example_
+```typescript
+ const schema = string().custom(uuidV5());
+ parseOrFail(schema, '550e8400-e29b-51d4-a716-446655440000'); // Valid
+ parseOrFail(schema, '550e8400-e29b-41d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v5'
+ parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v5'
+```
+* _See_ Error Translation Key = 's:uuidV5'
+        
+        
+##### validUrl (string)
+        
+```typescript
+import { validUrl } from 'bguard/string/validUrl';
+```
+        
+* _Description_ Asserts that the string value is a valid URL with optional protocol validation.
+* _Param_ {string} [protocol] The protocol that the URL must start with (e.g., 'http'). If not provided, any URL starting with 'http://' or 'https://' is considered valid.
+* _Throws_ {ValidationError} if the received value does not match the expected URL pattern.
+* _Example_
+```typescript
+ const schema = string().custom(validUrl()); // Validates any URL starting with 'http://' or 'https://'
+ parseOrFail(schema, 'http://example.com'); // Valid
+ parseOrFail(schema, 'https://example.com'); // Valid
+ parseOrFail(schema, 'ftp://example.com');   // Throws an error
+ parseOrFail(schema, 'http:example.com');    // Throws an error
+```
+* _See_ Error Translation Key = 's:url'
+        
 ### Contributing
 Contributions are welcome! Please open an issue or submit a pull request for any bugs or feature requests.

package/lib/asserts/number/index.js

@@ -1,9 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk4RNK3I74js = require('../../chunk-4RNK3I74.js');
-require('../../chunk-RQH4LXBW.js');
+var _chunkRD6TBCPQjs = require('../../chunk-RD6TBCPQ.js');
+require('../../chunk-KQKJASVB.js');
 require('../../chunk-J4VKFJQK.js');
 require('../../chunk-4CYIMDP2.js');
+require('../../chunk-42J6CHIO.js');
 require('../../chunk-JSGZ7DKT.js');
 require('../../chunk-EGEHSELT.js');
 require('../../chunk-IRG4OQAB.js');
@@ -11,5 +12,5 @@ require('../../chunk-5BVJ6YMH.js');
 require('../../chunk-WK4O3HH4.js');
 
 
-exports.number = _chunk4RNK3I74js.number;
+exports.number = _chunkRD6TBCPQjs.number;
 //# sourceMappingURL=index.js.map

package/lib/asserts/number/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/number/index.js"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC;AACE;AACF,yCAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/number/index.js"}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/number/index.js"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC;AACE;AACF,yCAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/number/index.js"}

package/lib/asserts/number/index.mjs

@@ -1,9 +1,10 @@
 import {
   number
-} from "../../chunk-B6TFELXR.mjs";
-import "../../chunk-CLG3QRZC.mjs";
+} from "../../chunk-PXBAS3GA.mjs";
+import "../../chunk-P7IXNCJG.mjs";
 import "../../chunk-NNFYXHLU.mjs";
 import "../../chunk-3O4WCRC2.mjs";
+import "../../chunk-ASZW6XRM.mjs";
 import "../../chunk-RYVUYVEE.mjs";
 import "../../chunk-DPBE7TAQ.mjs";
 import "../../chunk-PH2PMUZP.mjs";

package/lib/asserts/string/atLeastOneDigit.d.mts

@@ -0,0 +1,20 @@
+import { RequiredValidation } from '../../commonTypes.mjs';
+
+/**
+ * @description Asserts that a string value contains at least one digit.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value does not contain at least one digit.
+ * @example
+ * const schema = string().custom(atLeastOneDigit());
+ * parseOrFail(schema, 'abc123'); // Valid
+ * parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one digit'
+ *
+ * @translation Error Translation Key = 's:atLeastOneDigit'
+ */
+declare const atLeastOneDigit: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { atLeastOneDigit };

package/lib/asserts/string/atLeastOneDigit.d.ts

@@ -0,0 +1,20 @@
+import { RequiredValidation } from '../../commonTypes.js';
+
+/**
+ * @description Asserts that a string value contains at least one digit.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value does not contain at least one digit.
+ * @example
+ * const schema = string().custom(atLeastOneDigit());
+ * parseOrFail(schema, 'abc123'); // Valid
+ * parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one digit'
+ *
+ * @translation Error Translation Key = 's:atLeastOneDigit'
+ */
+declare const atLeastOneDigit: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { atLeastOneDigit };

package/lib/asserts/string/atLeastOneDigit.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/atLeastOneDigit.ts
+var digitRegExp = /\d/;
+var atLeastOneDigitErrorMessage = "The received value does not contain at least one digit";
+var atLeastOneDigitErrorKey = "s:atLeastOneDigit";
+var atLeastOneDigit = () => (received, ctx) => {
+  if (!digitRegExp.test(received)) _chunkWK4O3HH4js.guardException.call(void 0, "at least one digit", received, ctx, atLeastOneDigitErrorKey);
+};
+atLeastOneDigit.key = atLeastOneDigitErrorKey;
+atLeastOneDigit.message = atLeastOneDigitErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, atLeastOneDigit);
+
+
+exports.atLeastOneDigit = atLeastOneDigit;
+//# sourceMappingURL=atLeastOneDigit.js.map

package/lib/asserts/string/atLeastOneDigit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/atLeastOneDigit.js","../../../src/asserts/string/atLeastOneDigit.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,YAAA,EAAc,IAAA;AACpB,IAAM,4BAAA,EAA8B,wDAAA;AACpC,IAAM,wBAAA,EAA0B,mBAAA;AAazB,IAAM,gBAAA,EAAkB,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACpG,EAAA,GAAA,CAAI,CAAC,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,EAAG,6CAAA,oBAAe,EAAsB,QAAA,EAAU,GAAA,EAAK,uBAAuB,CAAA;AAC9G,CAAA;AAEA,eAAA,CAAgB,IAAA,EAAM,uBAAA;AACtB,eAAA,CAAgB,QAAA,EAAU,2BAAA;AAC1B,iDAAA,eAAkC,CAAA;ADRlC;AACE;AACF,0CAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/atLeastOneDigit.js","sourcesContent":[null,"import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst digitRegExp = /\\d/;\nconst atLeastOneDigitErrorMessage = 'The received value does not contain at least one digit';\nconst atLeastOneDigitErrorKey = 's:atLeastOneDigit';\n\n/**\n * @description Asserts that a string value contains at least one digit.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one digit.\n * @example\n * const schema = string().custom(atLeastOneDigit());\n * parseOrFail(schema, 'abc123'); // Valid\n * parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one digit'\n *\n * @translation Error Translation Key = 's:atLeastOneDigit'\n */\nexport const atLeastOneDigit = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!digitRegExp.test(received)) guardException('at least one digit', received, ctx, atLeastOneDigitErrorKey);\n};\n\natLeastOneDigit.key = atLeastOneDigitErrorKey;\natLeastOneDigit.message = atLeastOneDigitErrorMessage;\nsetToDefaultLocale(atLeastOneDigit);\n"]}

package/lib/asserts/string/atLeastOneDigit.mjs

@@ -0,0 +1,21 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/atLeastOneDigit.ts
+var digitRegExp = /\d/;
+var atLeastOneDigitErrorMessage = "The received value does not contain at least one digit";
+var atLeastOneDigitErrorKey = "s:atLeastOneDigit";
+var atLeastOneDigit = () => (received, ctx) => {
+  if (!digitRegExp.test(received)) guardException("at least one digit", received, ctx, atLeastOneDigitErrorKey);
+};
+atLeastOneDigit.key = atLeastOneDigitErrorKey;
+atLeastOneDigit.message = atLeastOneDigitErrorMessage;
+setToDefaultLocale(atLeastOneDigit);
+export {
+  atLeastOneDigit
+};
+//# sourceMappingURL=atLeastOneDigit.mjs.map

package/lib/asserts/string/atLeastOneDigit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/string/atLeastOneDigit.ts"],"sourcesContent":["import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst digitRegExp = /\\d/;\nconst atLeastOneDigitErrorMessage = 'The received value does not contain at least one digit';\nconst atLeastOneDigitErrorKey = 's:atLeastOneDigit';\n\n/**\n * @description Asserts that a string value contains at least one digit.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one digit.\n * @example\n * const schema = string().custom(atLeastOneDigit());\n * parseOrFail(schema, 'abc123'); // Valid\n * parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one digit'\n *\n * @translation Error Translation Key = 's:atLeastOneDigit'\n */\nexport const atLeastOneDigit = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!digitRegExp.test(received)) guardException('at least one digit', received, ctx, atLeastOneDigitErrorKey);\n};\n\natLeastOneDigit.key = atLeastOneDigitErrorKey;\natLeastOneDigit.message = atLeastOneDigitErrorMessage;\nsetToDefaultLocale(atLeastOneDigit);\n"],"mappings":";;;;;;;;AAIA,IAAM,cAAc;AACpB,IAAM,8BAA8B;AACpC,IAAM,0BAA0B;AAazB,IAAM,kBAAkB,MAA0B,CAAC,UAAkB,QAA0B;AACpG,MAAI,CAAC,YAAY,KAAK,QAAQ,EAAG,gBAAe,sBAAsB,UAAU,KAAK,uBAAuB;AAC9G;AAEA,gBAAgB,MAAM;AACtB,gBAAgB,UAAU;AAC1B,mBAAmB,eAAe;","names":[]}