bguard 0.5.0 → 0.6.0

package/lib/chunk-LXZTBF7F.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/bigint/bigintMax.ts
+var bigintMaxErrorMessage = "The received value is greater than expected";
+var bigintMaxErrorKey = "bi:max";
+var bigintMax = (expected) => (received, ctx) => {
+  if (expected < received) ctx.addIssue(expected, received, bigintMaxErrorKey);
+};
+bigintMax.key = bigintMaxErrorKey;
+bigintMax.message = bigintMaxErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, bigintMax);
+
+
+
+exports.bigintMax = bigintMax;
+//# sourceMappingURL=chunk-LXZTBF7F.js.map

package/lib/chunk-LXZTBF7F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-LXZTBF7F.js","../src/asserts/bigint/bigintMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,sBAAA,EAAwB,6CAAA;AAC9B,IAAM,kBAAA,EAAoB,QAAA;AAenB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,SAAA,EAAW,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,iBAAiB,CAAA;AAC7E,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADd5B;AACA;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-LXZTBF7F.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst bigintMaxErrorMessage = 'The received value is greater than expected';\nconst bigintMaxErrorKey = 'bi:max';\n\n/**\n * @description Asserts that a bigint value does not exceed a specified maximum value.\n * @param {bigint} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received bigint and an exception context.\n * @throws {ValidationError} if the received value exceeds the expected maximum value.\n * @example\n * const schema = bigint().custom(bigintMax(100n));\n * parseOrFail(schema, 99n);  // Valid\n * parseOrFail(schema, 100n); // Valid\n * parseOrFail(schema, 101n); // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'bi:max'\n */\nexport const bigintMax =\n  (expected: bigint): RequiredValidation =>\n  (received: bigint, ctx: ExceptionContext) => {\n    if (expected < received) ctx.addIssue(expected, received, bigintMaxErrorKey);\n  };\n\nbigintMax.key = bigintMaxErrorKey;\nbigintMax.message = bigintMaxErrorMessage;\nsetToDefaultLocale(bigintMax);\n"]}

package/lib/chunk-M2GOQ7TZ.mjs

@@ -0,0 +1,21 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/object/maxKeys.ts
+var maxKeysErrorMessage = "The received number of keys is greater than expected";
+var maxKeysErrorKey = "o:maxKeys";
+var maxKeys = (expected) => (receivedObject, ctx) => {
+  const keysCount = Object.keys(receivedObject).length;
+  if (keysCount > expected) {
+    ctx.addIssue(expected, keysCount, maxKeysErrorKey);
+  }
+};
+maxKeys.key = maxKeysErrorKey;
+maxKeys.message = maxKeysErrorMessage;
+setToDefaultLocale(maxKeys);
+
+export {
+  maxKeys
+};
+//# sourceMappingURL=chunk-M2GOQ7TZ.mjs.map

package/lib/chunk-M2GOQ7TZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/object/maxKeys.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxKeysErrorMessage = 'The received number of keys is greater than expected';\nconst maxKeysErrorKey = 'o:maxKeys';\n\n/**\n * @description Ensures that the object has no more than the specified number of keys.\n * @param {number} expected - The maximum number of keys allowed in the object.\n * @returns {RequiredValidation} A validation function that takes a received object and an exception context.\n * @throws {ValidationError} if the number of the received keys is greater than the expected value.\n * @example\n * const schema = object({\n *   name: string(),\n *   email: string(),\n * })\n *   .allowUnrecognized()\n *   .custom(maxKeys(2));\n *\n * // This will pass\n * parseOrFail(schema, { name: 'John', email: 'john@example.com' });\n *\n * // This will throw an error because there are 3 keys\n * parseOrFail(schema, { name: 'John', email: 'john@example.com', address: '123 Main St' });\n *\n * @translation Error Translation Key = 'o:maxKeys'\n */\nexport const maxKeys =\n  (expected: number): RequiredValidation =>\n  (receivedObject: Record<string, unknown>, ctx: ExceptionContext) => {\n    const keysCount = Object.keys(receivedObject).length;\n    if (keysCount > expected) {\n      ctx.addIssue(expected, keysCount, maxKeysErrorKey);\n    }\n  };\n\nmaxKeys.key = maxKeysErrorKey;\nmaxKeys.message = maxKeysErrorMessage;\nsetToDefaultLocale(maxKeys);\n"],"mappings":";;;;;AAGA,IAAM,sBAAsB;AAC5B,IAAM,kBAAkB;AAuBjB,IAAM,UACX,CAAC,aACD,CAAC,gBAAyC,QAA0B;AAClE,QAAM,YAAY,OAAO,KAAK,cAAc,EAAE;AAC9C,MAAI,YAAY,UAAU;AACxB,QAAI,SAAS,UAAU,WAAW,eAAe;AAAA,EACnD;AACF;AAEF,QAAQ,MAAM;AACd,QAAQ,UAAU;AAClB,mBAAmB,OAAO;","names":[]}

package/lib/{chunk-CCNK27CX.mjs → chunk-M3HYPZLE.mjs}

@@ -1,14 +1,14 @@
 import {
   CommonSchema
-} from "./chunk-UEYMBPZN.mjs";
-import {
-  ctxSymbol
-} from "./chunk-MQRXWXHP.mjs";
+} from "./chunk-QIPGUTIG.mjs";
 import {
   BuildSchemaError
 } from "./chunk-ZTCXXAKD.mjs";
+import {
+  ctxSymbol
+} from "./chunk-2ANPCB4O.mjs";
 
-// src/schemas/ObjectSchema.ts
+// src/asserts/object/index.ts
 var ObjectSchema = class extends CommonSchema {
   _object = 1;
   constructor(ctx, shapeSchema) {
@@ -25,13 +25,12 @@ var ObjectSchema = class extends CommonSchema {
     }
   }
   /**
-   * Allows unrecognized properties in the validated object.
+   * @method allowUnrecognized
+   * @description Allows unrecognized properties in the validated object.
    * When this method is called, the validation will not fail
    * if the received object contains properties not specified
    * in the validation schema.
-   *
    * @returns {this} The current ObjectSchema instance.
-   *
    * @example
    *  const userSchema = object({
    *    name: string(),
@@ -40,14 +39,19 @@ var ObjectSchema = class extends CommonSchema {
    *
    * parseOrFail(userSchema, ({ name: 'John', age: 30, extra: 'value' }););
    * //  No error thrown
+   *
+   * @public
    */
   allowUnrecognized() {
     this[ctxSymbol].allowUnrecognizedObjectProps = true;
     return this;
   }
 };
+function object(shapeSchema) {
+  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema);
+}
 
 export {
-  ObjectSchema
+  object
 };
-//# sourceMappingURL=chunk-CCNK27CX.mjs.map
+//# sourceMappingURL=chunk-M3HYPZLE.mjs.map

package/lib/chunk-M3HYPZLE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/object/index.ts"],"sourcesContent":["import { WithObject } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ctxSymbol } from '../../helpers/constants';\nimport { CommonSchema, ValidatorContext, type ObjectShapeSchemaType } from '../../core';\n\nclass ObjectSchema extends CommonSchema {\n  protected _object = 1;\n  constructor(ctx: ValidatorContext, shapeSchema: ObjectShapeSchemaType) {\n    super(ctx);\n    this.validateObjectEntry(shapeSchema);\n    this[ctxSymbol].object = shapeSchema;\n  }\n\n  private validateObjectEntry(shapeSchema: ObjectShapeSchemaType) {\n    if (!shapeSchema) throw new BuildSchemaError('Missing schema in object method');\n    if (shapeSchema instanceof CommonSchema) throw new BuildSchemaError('Invalid schema in object');\n    for (const [key, value] of Object.entries(shapeSchema)) {\n      if (!(value instanceof CommonSchema))\n        throw new BuildSchemaError(`Invalid schema in object method for property '${key}'`);\n    }\n  }\n\n  /**\n   * @method allowUnrecognized\n   * @description Allows unrecognized properties in the validated object.\n   * When this method is called, the validation will not fail\n   * if the received object contains properties not specified\n   * in the validation schema.\n   * @returns {this} The current ObjectSchema instance.\n   * @example\n   *  const userSchema = object({\n   *    name: string(),\n   *    age: number(),\n   *  }).allowUnrecognized();\n   *\n   * parseOrFail(userSchema, ({ name: 'John', age: 30, extra: 'value' }););\n   * //  No error thrown\n   *\n   * @public\n   */\n  public allowUnrecognized(): this {\n    this[ctxSymbol].allowUnrecognizedObjectProps = true;\n    return this;\n  }\n}\n\n/**\n * @description Creates a new schema for validating objects where each property must match the specified schema.\n * @template T\n * @param {T} shapeSchema - The schema that each property of the object must match.\n * @returns {WithObject<ObjectSchema, T>} A new instance of `ObjectSchema` for validating objects with properties matching the specified schema.\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number()\n * });\n * parseOrFail(schema, { name: 'John', age: 30 }); // Validates successfully\n * parseOrFail(schema, { name: 'John', age: '30' }); // Throws a validation error\n *\n * @instance Of ObjectSchema\n */\nexport function object<T extends ObjectShapeSchemaType>(shapeSchema: T): WithObject<ObjectSchema, T> {\n  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema) as WithObject<ObjectSchema, T>;\n}\n"],"mappings":";;;;;;;;;;;AAKA,IAAM,eAAN,cAA2B,aAAa;AAAA,EAC5B,UAAU;AAAA,EACpB,YAAY,KAAuB,aAAoC;AACrE,UAAM,GAAG;AACT,SAAK,oBAAoB,WAAW;AACpC,SAAK,SAAS,EAAE,SAAS;AAAA,EAC3B;AAAA,EAEQ,oBAAoB,aAAoC;AAC9D,QAAI,CAAC,YAAa,OAAM,IAAI,iBAAiB,iCAAiC;AAC9E,QAAI,uBAAuB,aAAc,OAAM,IAAI,iBAAiB,0BAA0B;AAC9F,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,GAAG;AACtD,UAAI,EAAE,iBAAiB;AACrB,cAAM,IAAI,iBAAiB,iDAAiD,GAAG,GAAG;AAAA,IACtF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,oBAA0B;AAC/B,SAAK,SAAS,EAAE,+BAA+B;AAC/C,WAAO;AAAA,EACT;AACF;AAiBO,SAAS,OAAwC,aAA6C;AACnG,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,EAAE,GAAG,WAAW;AAC5E;","names":[]}

package/lib/chunk-MCQHWS3E.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/number/negative.ts
+var negativeErrorMessage = "The received value is not a negative number";
+var negativeErrorKey = "n:negative";
+var negative = () => (received, ctx) => {
+  if (received >= 0) ctx.addIssue("negative", received, negativeErrorKey);
+};
+negative.key = negativeErrorKey;
+negative.message = negativeErrorMessage;
+setToDefaultLocale(negative);
+
+export {
+  negative
+};
+//# sourceMappingURL=chunk-MCQHWS3E.mjs.map

package/lib/chunk-MCQHWS3E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/negative.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst negativeErrorMessage = 'The received value is not a negative number';\nconst negativeErrorKey = 'n:negative';\n\n/**\n * @description Asserts that a number value is negative (less than zero).\n * @returns {RequiredValidation} A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is not negative.\n * @example\n * const schema = number().custom(negative());\n * parseOrFail(schema, -10); // Valid\n * parseOrFail(schema, 0);  // Throws an error: 'The received value is not a negative number'\n * parseOrFail(schema, 5);  // Throws an error: 'The received value is not a negative number'\n *\n * @translation - Error Translation Key = 'n:negative'\n */\nexport const negative = (): RequiredValidation => (received: number, ctx: ExceptionContext) => {\n  if (received >= 0) ctx.addIssue('negative', received, negativeErrorKey);\n};\n\nnegative.key = negativeErrorKey;\nnegative.message = negativeErrorMessage;\nsetToDefaultLocale(negative);\n"],"mappings":";;;;;AAGA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAclB,IAAM,WAAW,MAA0B,CAAC,UAAkB,QAA0B;AAC7F,MAAI,YAAY,EAAG,KAAI,SAAS,YAAY,UAAU,gBAAgB;AACxE;AAEA,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/chunk-MHWPSQB3.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/string/upperCase.ts
+var upperCaseErrorMessage = "The received value is not in uppercase";
+var upperCaseErrorKey = "s:upperCase";
+var upperCase = () => (received, ctx) => {
+  if (received !== received.toUpperCase()) {
+    ctx.addIssue("upper case", received, upperCaseErrorKey);
+  }
+};
+upperCase.key = upperCaseErrorKey;
+upperCase.message = upperCaseErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, upperCase);
+
+
+
+exports.upperCase = upperCase;
+//# sourceMappingURL=chunk-MHWPSQB3.js.map

package/lib/chunk-MHWPSQB3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-MHWPSQB3.js","../src/asserts/string/upperCase.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,sBAAA,EAAwB,wCAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EAAY,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC9F,EAAA,GAAA,CAAI,SAAA,IAAa,QAAA,CAAS,WAAA,CAAY,CAAA,EAAG;AACvC,IAAA,GAAA,CAAI,QAAA,CAAS,YAAA,EAAc,QAAA,EAAU,iBAAiB,CAAA;AAAA,EACxD;AACF,CAAA;AAEA,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADX5B;AACA;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-MHWPSQB3.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst upperCaseErrorMessage = 'The received value is not in uppercase';\nconst upperCaseErrorKey = 's:upperCase';\n\n/**\n * @description Asserts that a string value is entirely in uppercase.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not in uppercase.\n * @example\n * const schema = string().custom(upperCase());\n * parseOrFail(schema, 'VALID');    // Valid\n * parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'\n * parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'\n *\n * @translation Error Translation Key = 's:upperCase'\n */\nexport const upperCase = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (received !== received.toUpperCase()) {\n    ctx.addIssue('upper case', received, upperCaseErrorKey);\n  }\n};\n\nupperCase.key = upperCaseErrorKey;\nupperCase.message = upperCaseErrorMessage;\nsetToDefaultLocale(upperCase);\n"]}

package/lib/chunk-N3EHGKZV.mjs

@@ -0,0 +1,25 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/validUrl.ts
+var validUrlErrorMessage = "The received value is not a valid URL";
+var validUrlErrorKey = "s:validUrl";
+var urlRegex = /^(http:\/\/|https:\/\/)([a-zA-Z0-9\-.]+)(:\d+)?(\/[^\s]*)?$/;
+var validUrl = (protocol) => (received, ctx) => {
+  let regex = urlRegex;
+  if (protocol) {
+    regex = new RegExp(`^${protocol}:\\/\\/([a-zA-Z0-9\\-\\.]+)(:[0-9]+)?(\\/[^\\s]*)?$`);
+  }
+  if (!regex.test(received)) {
+    ctx.addIssue("Invalid URL", received, validUrlErrorKey);
+  }
+};
+validUrl.key = validUrlErrorKey;
+validUrl.message = validUrlErrorMessage;
+setToDefaultLocale(validUrl);
+
+export {
+  validUrl
+};
+//# sourceMappingURL=chunk-N3EHGKZV.mjs.map

package/lib/chunk-N3EHGKZV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/validUrl.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst validUrlErrorMessage = 'The received value is not a valid URL';\nconst validUrlErrorKey = 's:validUrl';\n\nconst urlRegex = /^(http:\\/\\/|https:\\/\\/)([a-zA-Z0-9\\-.]+)(:\\d+)?(\\/[^\\s]*)?$/;\n\n/**\n * @description Asserts that the string value is a valid URL with optional protocol validation.\n * @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.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not match the expected URL pattern.\n * @example\n * const schema = string().custom(validUrl()); // Validates any URL starting with 'http://' or 'https://'\n * parseOrFail(schema, 'http://example.com'); // Valid\n * parseOrFail(schema, 'https://example.com'); // Valid\n * parseOrFail(schema, 'ftp://example.com');   // Throws an error\n * parseOrFail(schema, 'http:example.com');    // Throws an error\n *\n * @translation Error Translation Key = 's:url'\n */\nexport const validUrl =\n  (protocol?: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    let regex = urlRegex;\n    if (protocol) {\n      regex = new RegExp(`^${protocol}:\\\\/\\\\/([a-zA-Z0-9\\\\-\\\\.]+)(:[0-9]+)?(\\\\/[^\\\\s]*)?$`);\n    }\n\n    if (!regex.test(received)) {\n      ctx.addIssue('Invalid URL', received, validUrlErrorKey);\n    }\n  };\n\nvalidUrl.key = validUrlErrorKey;\nvalidUrl.message = validUrlErrorMessage;\nsetToDefaultLocale(validUrl);\n"],"mappings":";;;;;AAGA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAEzB,IAAM,WAAW;AAgBV,IAAM,WACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,QAAQ;AACZ,MAAI,UAAU;AACZ,YAAQ,IAAI,OAAO,IAAI,QAAQ,qDAAqD;AAAA,EACtF;AAEA,MAAI,CAAC,MAAM,KAAK,QAAQ,GAAG;AACzB,QAAI,SAAS,eAAe,UAAU,gBAAgB;AAAA,EACxD;AACF;AAEF,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/chunk-NBR3QGKW.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkVN4GLOENjs = require('./chunk-VN4GLOEN.js');
+
+
+var _chunkAXKX5BGHjs = require('./chunk-AXKX5BGH.js');
+
+// src/asserts/date/index.ts
+function date() {
+  return new DateSchema({ type: ["object"], requiredValidations: [] });
+}
+var DateSchema = (_class = class extends _chunkVN4GLOENjs.CommonSchema {
+  __init() {this._date = 1}
+  constructor(ctx) {
+    super(ctx);_class.prototype.__init.call(this);;
+    this[_chunkAXKX5BGHjs.ctxSymbol].date = true;
+  }
+}, _class);
+
+
+
+exports.date = date;
+//# sourceMappingURL=chunk-NBR3QGKW.js.map

package/lib/chunk-NBR3QGKW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-NBR3QGKW.js","../src/asserts/date/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACOO,SAAS,IAAA,CAAA,EAAyC;AACvD,EAAA,OAAO,IAAI,UAAA,CAAW,EAAE,IAAA,EAAM,CAAC,QAAQ,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAC,CAAA;AACrE;AAEA,IAAM,WAAA,YAAN,MAAA,QAAyB,8BAAa;AAAA,iBAC1B,MAAA,EAAQ,EAAA;AAAA,EAElB,WAAA,CAAY,GAAA,EAAuB;AACjC,IAAA,KAAA,CAAM,GAAG,qCAAA;AACT,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,KAAA,EAAO,IAAA;AAAA,EACzB;AACF,UAAA;ADPA;AACA;AACE;AACF,oBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-NBR3QGKW.js","sourcesContent":[null,"import { WithBGuardType } from '../../commonTypes';\nimport { ctxSymbol } from '../../helpers/constants';\nimport { CommonSchema, ValidatorContext } from '../../core';\n\n/**\n * @description Creates a new schema for validating date values.\n * @returns {WithBGuardType<DateSchema, Date>} A new instance of `DateSchema` for validating booleans.\n * @example\n * const schema = date();\n * parseOrFail(schema, true); // Validates successfully\n * parseOrFail(schema, 'true'); // Throws a validation error\n *\n * @instance Of DateSchema\n */\nexport function date(): WithBGuardType<DateSchema, Date> {\n  return new DateSchema({ type: ['object'], requiredValidations: [] }) as WithBGuardType<DateSchema, Date>;\n}\n\nclass DateSchema extends CommonSchema {\n  protected _date = 1;\n\n  constructor(ctx: ValidatorContext) {\n    super(ctx);\n    this[ctxSymbol].date = true;\n  }\n}\n"]}

package/lib/{chunk-U3DJ354I.mjs → chunk-NFD7D5GZ.mjs}

@@ -1,33 +1,38 @@
-import {
-  equalTo
-} from "./chunk-EMOOEIPZ.mjs";
 import {
   oneOfValues
-} from "./chunk-P54CF5QN.mjs";
+} from "./chunk-W3U7RYLP.mjs";
 import {
-  ONLY_ONCE
-} from "./chunk-ASZW6XRM.mjs";
+  equalTo
+} from "./chunk-4ZKU4RJL.mjs";
 import {
   _setStrictType
-} from "./chunk-YSCVE4PJ.mjs";
+} from "./chunk-THU5VBSO.mjs";
 import {
   CommonSchema
-} from "./chunk-UEYMBPZN.mjs";
+} from "./chunk-QIPGUTIG.mjs";
 import {
   BuildSchemaError
 } from "./chunk-ZTCXXAKD.mjs";
+import {
+  ONLY_ONCE
+} from "./chunk-2ANPCB4O.mjs";
 
-// src/schemas/BigIntSchema.ts
+// src/asserts/bigint/index.ts
+function bigint() {
+  return new BigIntSchema({ type: ["bigint"], requiredValidations: [] });
+}
 var BigIntSchema = class extends CommonSchema {
   _bigint = 1;
   limit;
   /**
-   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
-   *
+   * @method equalTo
+   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
    * @param expectedValue - The value that the schema must exactly match.
-   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @returns The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @example
+   * bigint().equalTo(42n); // Infers the type 42n
    *
-   * @example - bigint().equalTo(42n); // Infers the type 42n
+   * @public
    */
   equalTo(expectedValue) {
     this.defaultValueCheck();
@@ -36,13 +41,14 @@ var BigIntSchema = class extends CommonSchema {
     return this.custom(equalTo(expectedValue));
   }
   /**
-   * Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.
-   *
+   * @method oneOfValues
+   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.
    * @param expectedValues - An array of values that the schema can match.
-   * @returns - The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
-   *
+   * @returns The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
    * @example
    * bigint().oneOfValues([5n, 7n]); // Infers the type 5n | 7n
+   *
+   * @public
    */
   oneOfValues(expectedValue) {
     this.defaultValueCheck();
@@ -60,6 +66,6 @@ var BigIntSchema = class extends CommonSchema {
 };
 
 export {
-  BigIntSchema
+  bigint
 };
-//# sourceMappingURL=chunk-U3DJ354I.mjs.map
+//# sourceMappingURL=chunk-NFD7D5GZ.mjs.map

package/lib/chunk-NFD7D5GZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/bigint/index.ts"],"sourcesContent":["import { WithBGuardType } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ONLY_ONCE } from '../../helpers/constants';\nimport { CommonSchema } from '../../core';\nimport { _setStrictType } from '../../helpers/setStrictType';\nimport { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description - Creates a new schema for validating bigint values.\n * @returns {WithBGuardType<BigIntSchema, bigint>} A new instance of `BigIntSchema` for validating bigints.\n * @example\n * const schema = bigint();\n * parseOrFail(schema, 42n); // Validates successfully\n * parseOrFail(schema, 42); // Throws a validation error\n * parseOrFail(schema, '42'); // Throws a validation error\n *\n * @instance Of BigIntSchema\n */\nexport function bigint(): WithBGuardType<BigIntSchema, bigint> {\n  return new BigIntSchema({ type: ['bigint'], requiredValidations: [] }) as WithBGuardType<BigIntSchema, bigint>;\n}\n\nclass BigIntSchema extends CommonSchema {\n  protected _bigint = 1;\n  private limit: boolean | undefined;\n\n  /**\n   * @method equalTo\n   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.\n   * @param expectedValue - The value that the schema must exactly match.\n   * @returns The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type\n   * @example\n   * bigint().equalTo(42n); // Infers the type 42n\n   *\n   * @public\n   */\n  public equalTo<Y extends bigint>(expectedValue: Y): WithBGuardType<this, Y> {\n    this.defaultValueCheck();\n    this.limitCheck();\n    _setStrictType(this, `${expectedValue}n`);\n    return this.custom(equalTo(expectedValue)) as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * @method oneOfValues\n   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.\n   * @param expectedValues - An array of values that the schema can match.\n   * @returns The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.\n   * @example\n   * bigint().oneOfValues([5n, 7n]); // Infers the type 5n | 7n\n   *\n   * @public\n   */\n  public oneOfValues<Y extends bigint>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    this.defaultValueCheck();\n    this.limitCheck();\n    _setStrictType(\n      this,\n      expectedValue.map((el) => `${el}n`),\n    );\n    return this.custom(oneOfValues(expectedValue)) as WithBGuardType<this, Y>;\n  }\n\n  private limitCheck() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n    this.limit = true;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBO,SAAS,SAA+C;AAC7D,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,QAAQ,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACvE;AAEA,IAAM,eAAN,cAA2B,aAAa;AAAA,EAC5B,UAAU;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,QAA0B,eAA2C;AAC1E,SAAK,kBAAkB;AACvB,SAAK,WAAW;AAChB,mBAAe,MAAM,GAAG,aAAa,GAAG;AACxC,WAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAA8B,eAA6C;AAChF,SAAK,kBAAkB;AACvB,SAAK,WAAW;AAChB;AAAA,MACE;AAAA,MACA,cAAc,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG;AAAA,IACpC;AACA,WAAO,KAAK,OAAO,YAAY,aAAa,CAAC;AAAA,EAC/C;AAAA,EAEQ,aAAa;AACnB,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AACpD,SAAK,QAAQ;AAAA,EACf;AACF;","names":[]}

package/lib/chunk-NOJB5GBZ.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/minLength.ts
+var minLengthErrorMessage = "The received value length is less than expected";
+var minLengthErrorKey = "s:minLength";
+var minLength = (expected) => (received, ctx) => {
+  if (received.length < expected) ctx.addIssue(expected, received, minLengthErrorMessage);
+};
+minLength.key = minLengthErrorKey;
+minLength.message = minLengthErrorMessage;
+setToDefaultLocale(minLength);
+
+export {
+  minLength
+};
+//# sourceMappingURL=chunk-NOJB5GBZ.mjs.map

package/lib/chunk-NOJB5GBZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/minLength.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minLengthErrorMessage = 'The received value length is less than expected';\nconst minLengthErrorKey = 's:minLength';\n\n/**\n * @description Asserts that the length of a string value is not less than a specified minimum length.\n * @param {number} expected The minimum required length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = string().custom(minLength(5));\n * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, 'adequate'); // Valid\n *\n * @translation Error Translation Key = 's:minLength'\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length < expected) ctx.addIssue(expected, received, minLengthErrorMessage);\n  };\n\nminLength.key = minLengthErrorKey;\nminLength.message = minLengthErrorMessage;\nsetToDefaultLocale(minLength);\n"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,SAAS,SAAS,SAAU,KAAI,SAAS,UAAU,UAAU,qBAAqB;AACxF;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/chunk-NS4GXUCA.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/bigint/bigintMinExcluded.ts
+var bigintMinExcludedErrorMessage = "The received value is less than or equal to expected";
+var bigintMinExcludedErrorKey = "bi:minExcluded";
+var bigintMinExcluded = (expected) => (received, ctx) => {
+  if (expected >= received) ctx.addIssue(expected, received, bigintMinExcludedErrorKey);
+};
+bigintMinExcluded.key = bigintMinExcludedErrorKey;
+bigintMinExcluded.message = bigintMinExcludedErrorMessage;
+setToDefaultLocale(bigintMinExcluded);
+
+export {
+  bigintMinExcluded
+};
+//# sourceMappingURL=chunk-NS4GXUCA.mjs.map

package/lib/chunk-NS4GXUCA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/bigint/bigintMinExcluded.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst bigintMinExcludedErrorMessage = 'The received value is less than or equal to expected';\nconst bigintMinExcludedErrorKey = 'bi:minExcluded';\n\n/**\n * @description Asserts that a bigint value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n * @param {bigint} expected The minimum allowable value, which is excluded.\n * @returns {RequiredValidation} A validation function that takes a received bigint and an exception context.\n * @throws {ValidationError} if the received value is less than or equal to the expected minimum value.\n * @example\n * const schema = bigint().custom(bigintMinExcluded(10n));\n * parseOrFail(schema, 11n);  // Valid\n * parseOrFail(schema, 10n); // Throws an error: 'The received value is less than or equal to expected'\n * parseOrFail(schema, 9n);  // Throws an error: 'The received value is less than or equal to expected'\n *\n * @translation Error Translation Key = 'bi:minExcluded'\n */\nexport const bigintMinExcluded =\n  (expected: bigint): RequiredValidation =>\n  (received: bigint, ctx: ExceptionContext) => {\n    if (expected >= received) ctx.addIssue(expected, received, bigintMinExcludedErrorKey);\n  };\n\nbigintMinExcluded.key = bigintMinExcludedErrorKey;\nbigintMinExcluded.message = bigintMinExcludedErrorMessage;\nsetToDefaultLocale(bigintMinExcluded);\n"],"mappings":";;;;;AAGA,IAAM,gCAAgC;AACtC,IAAM,4BAA4B;AAe3B,IAAM,oBACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,YAAY,SAAU,KAAI,SAAS,UAAU,UAAU,yBAAyB;AACtF;AAEF,kBAAkB,MAAM;AACxB,kBAAkB,UAAU;AAC5B,mBAAmB,iBAAiB;","names":[]}

package/lib/chunk-NY2TPU6O.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/array/maxArrayLength.ts
+var maxArrayLengthErrorMessage = "The received value length is greater than expected";
+var maxArrayLengthErrorKey = "a:maxArrayLength";
+var maxArrayLength = (expected) => (received, ctx) => {
+  if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorMessage);
+};
+maxArrayLength.key = maxArrayLengthErrorKey;
+maxArrayLength.message = maxArrayLengthErrorMessage;
+setToDefaultLocale(maxArrayLength);
+
+export {
+  maxArrayLength
+};
+//# sourceMappingURL=chunk-NY2TPU6O.mjs.map

package/lib/chunk-NY2TPU6O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/array/maxArrayLength.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxArrayLengthErrorMessage = 'The received value length is greater than expected';\nconst maxArrayLengthErrorKey = 'a:maxArrayLength';\n\n/**\n * @description Asserts that the length of an array is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the array.\n * @returns {RequiredValidation} A validation function that takes a received array and an exception context.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = array(string()).custom(maxArrayLength(3));\n * parseOrFail(schema, ['adequate', 'array']);   // Valid\n * parseOrFail(schema, ['adequate', 'array', 'length']);   // Valid\n * parseOrFail(schema, ['adequate', 'array', 'length', 'test']); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 'a:maxArrayLength'\n */\nexport const maxArrayLength =\n  (expected: number): RequiredValidation =>\n  (received: unknown[], ctx: ExceptionContext) => {\n    if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorMessage);\n  };\n\nmaxArrayLength.key = maxArrayLengthErrorKey;\nmaxArrayLength.message = maxArrayLengthErrorMessage;\nsetToDefaultLocale(maxArrayLength);\n"],"mappings":";;;;;AAGA,IAAM,6BAA6B;AACnC,IAAM,yBAAyB;AAexB,IAAM,iBACX,CAAC,aACD,CAAC,UAAqB,QAA0B;AAC9C,MAAI,SAAS,SAAS,SAAU,KAAI,SAAS,UAAU,UAAU,0BAA0B;AAC7F;AAEF,eAAe,MAAM;AACrB,eAAe,UAAU;AACzB,mBAAmB,cAAc;","names":[]}

package/lib/{chunk-QWPHP26D.mjs → chunk-OE3L7EKN.mjs}

@@ -30,7 +30,7 @@ function setToDefaultLocale({
 }
 function setLocale(lng, custom) {
   if (lng === "default") throw new BuildSchemaError("Invalid language");
-  if (!data[lng]) data[lng] = { ...defaultErrorMap };
+  data[lng] ??= { ...defaultErrorMap };
   const locale = data[lng];
   Object.entries(custom).forEach(([messageKey, messageValue]) => {
     locale[messageKey] = messageValue;
@@ -52,4 +52,4 @@ export {
   clearLocales,
   getTranslationByLocale
 };
-//# sourceMappingURL=chunk-QWPHP26D.mjs.map
+//# sourceMappingURL=chunk-OE3L7EKN.mjs.map

package/lib/chunk-OE3L7EKN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/translationMap.ts"],"sourcesContent":["import { BuildSchemaError } from './exceptions';\nimport type { TranslationErrorMap } from './commonTypes';\nimport type { RequiredValidation } from './core';\n\n// c: stands for common\nconst defaultErrorMap: TranslationErrorMap = {\n  //@@start\n  'c:optional': 'The required value is missing',\n  'c:nullable': 'Value should not be null',\n  'c:array': 'Expected an array but received a different type',\n  'c:objectType': 'Expected an object but received a different type',\n  'c:objectTypeAsArray': 'Expected an object but received an array. Invalid type of data',\n  'c:unrecognizedProperty': 'This property is not allowed in the object',\n  'c:requiredProperty': 'Missing required property in the object',\n  'c:invalidType': 'Invalid type of data',\n  'c:isBoolean': 'The received value is not {{e}}',\n  'c:date': 'The received value is not a valid instance of Date',\n  //@@end\n};\n\nlet data: Record<string, Record<string, string>> = {\n  default: { ...defaultErrorMap },\n};\n\nexport function setToDefaultLocale({\n  key,\n  message,\n}: {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (expected: any): RequiredValidation;\n  key: string;\n  message: string;\n}) {\n  const defaultLocale = data.default!;\n  if (defaultLocale[key]) throw new BuildSchemaError('Duplicate default message key');\n  defaultLocale[key] = message;\n}\n\nexport function setLocale(lng: string, custom: Partial<TranslationErrorMap>) {\n  if (lng === 'default') throw new BuildSchemaError('Invalid language');\n  data[lng] ??= { ...defaultErrorMap };\n  const locale = data[lng];\n  Object.entries(custom).forEach(([messageKey, messageValue]) => {\n    locale[messageKey] = messageValue!;\n  });\n}\n\nexport function clearLocales() {\n  data = {\n    default: { ...defaultErrorMap },\n  };\n}\n\nexport function getTranslationByLocale(lng?: string): TranslationErrorMap {\n  if (!lng) return data['default'] as TranslationErrorMap;\n  return (data[lng] ?? data['default']) as TranslationErrorMap;\n}\n"],"mappings":";;;;;AAKA,IAAM,kBAAuC;AAAA;AAAA,EAE3C,cAAc;AAAA,EACd,cAAc;AAAA,EACd,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,uBAAuB;AAAA,EACvB,0BAA0B;AAAA,EAC1B,sBAAsB;AAAA,EACtB,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,UAAU;AAAA;AAEZ;AAEA,IAAI,OAA+C;AAAA,EACjD,SAAS,EAAE,GAAG,gBAAgB;AAChC;AAEO,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AACF,GAKG;AACD,QAAM,gBAAgB,KAAK;AAC3B,MAAI,cAAc,GAAG,EAAG,OAAM,IAAI,iBAAiB,+BAA+B;AAClF,gBAAc,GAAG,IAAI;AACvB;AAEO,SAAS,UAAU,KAAa,QAAsC;AAC3E,MAAI,QAAQ,UAAW,OAAM,IAAI,iBAAiB,kBAAkB;AACpE,OAAK,GAAG,MAAM,EAAE,GAAG,gBAAgB;AACnC,QAAM,SAAS,KAAK,GAAG;AACvB,SAAO,QAAQ,MAAM,EAAE,QAAQ,CAAC,CAAC,YAAY,YAAY,MAAM;AAC7D,WAAO,UAAU,IAAI;AAAA,EACvB,CAAC;AACH;AAEO,SAAS,eAAe;AAC7B,SAAO;AAAA,IACL,SAAS,EAAE,GAAG,gBAAgB;AAAA,EAChC;AACF;AAEO,SAAS,uBAAuB,KAAmC;AACxE,MAAI,CAAC,IAAK,QAAO,KAAK,SAAS;AAC/B,SAAQ,KAAK,GAAG,KAAK,KAAK,SAAS;AACrC;","names":[]}

package/lib/chunk-OFZMO7PB.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/number/min.ts
+var minErrorMessage = "The received value is less than expected";
+var minErrorKey = "n:min";
+var min = (expected) => (received, ctx) => {
+  if (expected > received) ctx.addIssue(expected, received, minErrorKey);
+};
+min.key = minErrorKey;
+min.message = minErrorMessage;
+setToDefaultLocale(min);
+
+export {
+  min
+};
+//# sourceMappingURL=chunk-OFZMO7PB.mjs.map

package/lib/chunk-OFZMO7PB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/min.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst minErrorMessage = 'The received value is less than expected';\nconst minErrorKey = 'n:min';\n\n/**\n * @description Asserts that a number value is not less than a specified minimum value.\n * @param {number} expected The minimum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is less than the expected minimum value.\n * @example\n * const schema = number().custom(min(10));\n * parseOrFail(schema, 11);  // Valid\n * parseOrFail(schema, 10);  // Valid\n * parseOrFail(schema, 9);   // Throws an error: 'The received value is less than expected'\n *\n * @translation Error Translation Key = 'n:min'\n */\nexport const min =\n  (expected: number): RequiredValidation =>\n  (received: number, ctx: ExceptionContext) => {\n    if (expected > received) ctx.addIssue(expected, received, minErrorKey);\n  };\n\nmin.key = minErrorKey;\nmin.message = minErrorMessage;\nsetToDefaultLocale(min);\n"],"mappings":";;;;;AAGA,IAAM,kBAAkB;AACxB,IAAM,cAAc;AAeb,IAAM,MACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,WAAW,SAAU,KAAI,SAAS,UAAU,UAAU,WAAW;AACvE;AAEF,IAAI,MAAM;AACV,IAAI,UAAU;AACd,mBAAmB,GAAG;","names":[]}

package/lib/chunk-OHUOBIHX.mjs

@@ -0,0 +1,52 @@
+import {
+  ctxSymbol
+} from "./chunk-2ANPCB4O.mjs";
+
+// src/codeGen.ts
+function generateBaseType(schemaData) {
+  if (schemaData.date) return "Date";
+  if (schemaData.strictType) {
+    if (Array.isArray(schemaData.strictTypeValue)) return schemaData.strictTypeValue.join(" | ");
+    return schemaData.strictTypeValue;
+  }
+  if (!schemaData.type.length) return "";
+  const joined = schemaData.type.join(" | ");
+  return joined;
+}
+var INDENT_DEFAULT = `  `;
+function innerGenerator(schema, isProperty, indent = INDENT_DEFAULT) {
+  const schemaData = schema[ctxSymbol];
+  let code = "";
+  if (isProperty) {
+    code = code + (schemaData.isOptional ? "?: " : ": ");
+  }
+  if (schemaData.array) {
+    const innerArrayCode = innerGenerator(schemaData.array, false, indent + INDENT_DEFAULT);
+    code = code + (innerArrayCode.includes("|") ? `(${innerArrayCode})[]` : `${innerArrayCode}[]`);
+  }
+  if (schemaData.object) {
+    code = code + "{\n";
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(schemaData.object)) {
+      code = code + indent + keyOfSchema + innerGenerator(valueOfSchema, true, indent + INDENT_DEFAULT) + ";\n";
+    }
+    code = code + indent.slice(0, -INDENT_DEFAULT.length) + "}";
+  }
+  code = code + generateBaseType(schemaData);
+  code = code + (schemaData.isNullable ? " | null" : "");
+  code = code + (schemaData.isOptional ? " | undefined" : "");
+  return code;
+}
+function codeGen(schema) {
+  const result = innerGenerator(schema, false) + ";";
+  return result;
+}
+function codeGenWithName(typeName, schema) {
+  const result = "type " + typeName + " = " + codeGen(schema) + "\n";
+  return result;
+}
+
+export {
+  codeGen,
+  codeGenWithName
+};
+//# sourceMappingURL=chunk-OHUOBIHX.mjs.map

package/lib/chunk-OHUOBIHX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/codeGen.ts"],"sourcesContent":["import { ctxSymbol } from './helpers/constants';\nimport { type CommonSchema, type ValidatorContext } from './core';\n\nfunction generateBaseType(schemaData: ValidatorContext) {\n  if (schemaData.date) return 'Date';\n\n  if (schemaData.strictType) {\n    if (Array.isArray(schemaData.strictTypeValue)) return schemaData.strictTypeValue.join(' | ');\n    return schemaData.strictTypeValue;\n  }\n  if (!schemaData.type.length) return '';\n  const joined = schemaData.type.join(' | ');\n  return joined;\n}\n\nconst INDENT_DEFAULT = `  `;\n\nfunction innerGenerator(schema: CommonSchema, isProperty: boolean, indent = INDENT_DEFAULT): string {\n  const schemaData = schema[ctxSymbol];\n  let code = '';\n\n  if (isProperty) {\n    code = code + (schemaData.isOptional ? '?: ' : ': ');\n  }\n\n  if (schemaData.array) {\n    const innerArrayCode = innerGenerator(schemaData.array, false, indent + INDENT_DEFAULT);\n    code = code + (innerArrayCode.includes('|') ? `(${innerArrayCode})[]` : `${innerArrayCode}[]`);\n  }\n\n  if (schemaData.object) {\n    code = code + '{\\n';\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(schemaData.object)) {\n      code = code + indent + keyOfSchema + innerGenerator(valueOfSchema, true, indent + INDENT_DEFAULT) + ';\\n';\n    }\n    code = code + indent.slice(0, -INDENT_DEFAULT.length) + '}';\n  }\n\n  code = code + generateBaseType(schemaData);\n  code = code + (schemaData.isNullable ? ' | null' : '');\n  code = code + (schemaData.isOptional ? ' | undefined' : '');\n\n  return code;\n}\n\nexport function codeGen(schema: CommonSchema): string {\n  const result = innerGenerator(schema, false) + ';';\n  return result;\n}\n\nexport function codeGenWithName(typeName: string, schema: CommonSchema): string {\n  const result = 'type ' + typeName + ' = ' + codeGen(schema) + '\\n';\n  return result;\n}\n"],"mappings":";;;;;AAGA,SAAS,iBAAiB,YAA8B;AACtD,MAAI,WAAW,KAAM,QAAO;AAE5B,MAAI,WAAW,YAAY;AACzB,QAAI,MAAM,QAAQ,WAAW,eAAe,EAAG,QAAO,WAAW,gBAAgB,KAAK,KAAK;AAC3F,WAAO,WAAW;AAAA,EACpB;AACA,MAAI,CAAC,WAAW,KAAK,OAAQ,QAAO;AACpC,QAAM,SAAS,WAAW,KAAK,KAAK,KAAK;AACzC,SAAO;AACT;AAEA,IAAM,iBAAiB;AAEvB,SAAS,eAAe,QAAsB,YAAqB,SAAS,gBAAwB;AAClG,QAAM,aAAa,OAAO,SAAS;AACnC,MAAI,OAAO;AAEX,MAAI,YAAY;AACd,WAAO,QAAQ,WAAW,aAAa,QAAQ;AAAA,EACjD;AAEA,MAAI,WAAW,OAAO;AACpB,UAAM,iBAAiB,eAAe,WAAW,OAAO,OAAO,SAAS,cAAc;AACtF,WAAO,QAAQ,eAAe,SAAS,GAAG,IAAI,IAAI,cAAc,QAAQ,GAAG,cAAc;AAAA,EAC3F;AAEA,MAAI,WAAW,QAAQ;AACrB,WAAO,OAAO;AACd,eAAW,CAAC,aAAa,aAAa,KAAK,OAAO,QAAQ,WAAW,MAAM,GAAG;AAC5E,aAAO,OAAO,SAAS,cAAc,eAAe,eAAe,MAAM,SAAS,cAAc,IAAI;AAAA,IACtG;AACA,WAAO,OAAO,OAAO,MAAM,GAAG,CAAC,eAAe,MAAM,IAAI;AAAA,EAC1D;AAEA,SAAO,OAAO,iBAAiB,UAAU;AACzC,SAAO,QAAQ,WAAW,aAAa,YAAY;AACnD,SAAO,QAAQ,WAAW,aAAa,iBAAiB;AAExD,SAAO;AACT;AAEO,SAAS,QAAQ,QAA8B;AACpD,QAAM,SAAS,eAAe,QAAQ,KAAK,IAAI;AAC/C,SAAO;AACT;AAEO,SAAS,gBAAgB,UAAkB,QAA8B;AAC9E,QAAM,SAAS,UAAU,WAAW,QAAQ,QAAQ,MAAM,IAAI;AAC9D,SAAO;AACT;","names":[]}

package/lib/chunk-OMSHZITC.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/string/atLeastOneUpperChar.ts
+var atLeastOneUpperCharErrorMessage = "The received value does not contain at least one uppercase character";
+var atLeastOneUpperCharErrorKey = "s:atLeastOneUpperChar";
+var atLeastOneUpperChar = () => (received, ctx) => {
+  const upperCharRegExp = /[A-Z]/;
+  if (!upperCharRegExp.test(received))
+    ctx.addIssue("at least one uppercase character", received, atLeastOneUpperCharErrorKey);
+};
+atLeastOneUpperChar.key = atLeastOneUpperCharErrorKey;
+atLeastOneUpperChar.message = atLeastOneUpperCharErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, atLeastOneUpperChar);
+
+
+
+exports.atLeastOneUpperChar = atLeastOneUpperChar;
+//# sourceMappingURL=chunk-OMSHZITC.js.map

package/lib/chunk-OMSHZITC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-OMSHZITC.js","../src/asserts/string/atLeastOneUpperChar.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,gCAAA,EAAkC,sEAAA;AACxC,IAAM,4BAAA,EAA8B,uBAAA;AAa7B,IAAM,oBAAA,EAAsB,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACxG,EAAA,MAAM,gBAAA,EAAkB,OAAA;AACxB,EAAA,GAAA,CAAI,CAAC,eAAA,CAAgB,IAAA,CAAK,QAAQ,CAAA;AAChC,IAAA,GAAA,CAAI,QAAA,CAAS,kCAAA,EAAoC,QAAA,EAAU,2BAA2B,CAAA;AAC1F,CAAA;AAEA,mBAAA,CAAoB,IAAA,EAAM,2BAAA;AAC1B,mBAAA,CAAoB,QAAA,EAAU,+BAAA;AAC9B,iDAAA,mBAAsC,CAAA;ADVtC;AACA;AACE;AACF,kDAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-OMSHZITC.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneUpperCharErrorMessage = 'The received value does not contain at least one uppercase character';\nconst atLeastOneUpperCharErrorKey = 's:atLeastOneUpperChar';\n\n/**\n * @description Asserts that a string value contains at least one uppercase character.\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 uppercase character.\n * @example\n * const schema = string().custom(atLeastOneUpperChar());\n * parseOrFail(schema, 'abcDEF'); // Valid\n * parseOrFail(schema, 'abcdef'); // Throws an error: 'The received value does not contain at least one uppercase character'\n *\n * @translation Error Translation Key = 's:atLeastOneUpperChar'\n */\nexport const atLeastOneUpperChar = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  const upperCharRegExp = /[A-Z]/;\n  if (!upperCharRegExp.test(received))\n    ctx.addIssue('at least one uppercase character', received, atLeastOneUpperCharErrorKey);\n};\n\natLeastOneUpperChar.key = atLeastOneUpperCharErrorKey;\natLeastOneUpperChar.message = atLeastOneUpperCharErrorMessage;\nsetToDefaultLocale(atLeastOneUpperChar);\n"]}

package/lib/chunk-OQYS7JVF.js

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkVBTWYDEMjs = require('./chunk-VBTWYDEM.js');
+
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+
+var _chunkFIDPCCCWjs = require('./chunk-FIDPCCCW.js');
+
+// src/asserts/date/dateMax.ts
+var dateMaxErrorMessage = "The received value is greater than expected";
+var dateMaxErrorKey = "dt:max";
+var dateMax = (expected) => {
+  const transformedExpected = typeof expected === "string" ? new Date(expected) : expected;
+  if (!_chunkVBTWYDEMjs.isValidDateInner.call(void 0, transformedExpected)) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid date in Date assertion");
+  return (received, ctx) => {
+    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);
+  };
+};
+dateMax.key = dateMaxErrorKey;
+dateMax.message = dateMaxErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, dateMax);
+
+
+
+exports.dateMax = dateMax;
+//# sourceMappingURL=chunk-OQYS7JVF.js.map

package/lib/chunk-OQYS7JVF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-OQYS7JVF.js","../src/asserts/date/dateMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACLA,IAAM,oBAAA,EAAsB,6CAAA;AAC5B,IAAM,gBAAA,EAAkB,QAAA;AAcjB,IAAM,QAAA,EAAU,CAAC,QAAA,EAAA,GAAgD;AACtE,EAAA,MAAM,oBAAA,EAAsB,OAAO,SAAA,IAAa,SAAA,EAAW,IAAI,IAAA,CAAK,QAAQ,EAAA,EAAI,QAAA;AAChF,EAAA,GAAA,CAAI,CAAC,+CAAA,mBAAoC,CAAA,EAAG,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AACvG,EAAA,OAAO,CAAC,QAAA,EAAgB,GAAA,EAAA,GAA0B;AAChD,IAAA,GAAA,CAAI,oBAAA,EAAsB,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,mBAAA,EAAqB,QAAA,EAAU,eAAe,CAAA;AAAA,EACjG,CAAA;AACF,CAAA;AAEA,OAAA,CAAQ,IAAA,EAAM,eAAA;AACd,OAAA,CAAQ,QAAA,EAAU,mBAAA;AAClB,iDAAA,OAA0B,CAAA;ADP1B;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-OQYS7JVF.js","sourcesContent":[null,"import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMaxErrorMessage = 'The received value is greater than expected';\nconst dateMaxErrorKey = 'dt:max';\n/**\n * @description Asserts that a date value is not greater than a specified maximum value.\n * @param {Date | string} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is greater than the expected maximum value.\n * @example\n * const schema = date().custom(dateMax('2024-12-31'));\n * parseOrFail(schema, new Date('2024-12-30'));  // Valid\n * parseOrFail(schema, new Date('2024-12-31'));  // Valid\n * parseOrFail(schema, new Date('2025-01-01'));  // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'dt:max'\n */\nexport const dateMax = (expected: Date | string): RequiredValidation => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);\n  };\n};\n\ndateMax.key = dateMaxErrorKey;\ndateMax.message = dateMaxErrorMessage;\nsetToDefaultLocale(dateMax);\n"]}

package/lib/chunk-OSFIPFQ3.mjs

@@ -0,0 +1,28 @@
+import {
+  isValidDateInner
+} from "./chunk-YBVMP4EI.mjs";
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-ZTCXXAKD.mjs";
+
+// src/asserts/date/dateMax.ts
+var dateMaxErrorMessage = "The received value is greater than expected";
+var dateMaxErrorKey = "dt:max";
+var dateMax = (expected) => {
+  const transformedExpected = typeof expected === "string" ? new Date(expected) : expected;
+  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError("Invalid date in Date assertion");
+  return (received, ctx) => {
+    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);
+  };
+};
+dateMax.key = dateMaxErrorKey;
+dateMax.message = dateMaxErrorMessage;
+setToDefaultLocale(dateMax);
+
+export {
+  dateMax
+};
+//# sourceMappingURL=chunk-OSFIPFQ3.mjs.map

package/lib/chunk-OSFIPFQ3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/date/dateMax.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMaxErrorMessage = 'The received value is greater than expected';\nconst dateMaxErrorKey = 'dt:max';\n/**\n * @description Asserts that a date value is not greater than a specified maximum value.\n * @param {Date | string} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is greater than the expected maximum value.\n * @example\n * const schema = date().custom(dateMax('2024-12-31'));\n * parseOrFail(schema, new Date('2024-12-30'));  // Valid\n * parseOrFail(schema, new Date('2024-12-31'));  // Valid\n * parseOrFail(schema, new Date('2025-01-01'));  // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'dt:max'\n */\nexport const dateMax = (expected: Date | string): RequiredValidation => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);\n  };\n};\n\ndateMax.key = dateMaxErrorKey;\ndateMax.message = dateMaxErrorMessage;\nsetToDefaultLocale(dateMax);\n"],"mappings":";;;;;;;;;;;AAKA,IAAM,sBAAsB;AAC5B,IAAM,kBAAkB;AAcjB,IAAM,UAAU,CAAC,aAAgD;AACtE,QAAM,sBAAsB,OAAO,aAAa,WAAW,IAAI,KAAK,QAAQ,IAAI;AAChF,MAAI,CAAC,iBAAiB,mBAAmB,EAAG,OAAM,IAAI,iBAAiB,gCAAgC;AACvG,SAAO,CAAC,UAAgB,QAA0B;AAChD,QAAI,sBAAsB,SAAU,KAAI,SAAS,qBAAqB,UAAU,eAAe;AAAA,EACjG;AACF;AAEA,QAAQ,MAAM;AACd,QAAQ,UAAU;AAClB,mBAAmB,OAAO;","names":[]}