bguard 0.6.0 → 0.7.1

package/lib/{chunk-UYQFYQQG.mjs → chunk-J3EKIWPZ.mjs}

@@ -1,21 +1,24 @@
+import {
+  equalTo
+} from "./chunk-YQP44G45.mjs";
 import {
   oneOfValues
-} from "./chunk-W3U7RYLP.mjs";
+} from "./chunk-D42AL6CN.mjs";
 import {
-  equalTo
-} from "./chunk-4ZKU4RJL.mjs";
+  _quoteStringLiteral
+} from "./chunk-POPLWPM4.mjs";
 import {
   _setStrictType
-} from "./chunk-THU5VBSO.mjs";
+} from "./chunk-IIL6D2UL.mjs";
 import {
   CommonSchema
-} from "./chunk-QIPGUTIG.mjs";
-import {
-  BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-LDZFOOWN.mjs";
 import {
   ONLY_ONCE
-} from "./chunk-2ANPCB4O.mjs";
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
 
 // src/asserts/string/index.ts
 function string() {
@@ -28,42 +31,50 @@ var StringSchema = class extends CommonSchema {
    * @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 A new schema restricted to the specified value, with the literal value inferred as the TypeScript type
    * @example
    * string().equalTo('hello'); // Infers the type 'hello'
    *
    * @public
    */
   equalTo(expectedValue) {
-    this.limitCheck();
-    _setStrictType(this, `'${expectedValue}'`);
-    return this.custom(equalTo(expectedValue));
+    this.limitGuard();
+    const next = this.custom(equalTo(expectedValue));
+    next.limit = true;
+    _setStrictType(next, _quoteStringLiteral(expectedValue));
+    return next;
   }
   /**
    * @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 A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
    * @example
    * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'
    *
    * @public
    */
   oneOfValues(expectedValue) {
-    this.limitCheck();
+    this.limitGuard();
+    const next = this.custom(oneOfValues(expectedValue));
+    next.limit = true;
     _setStrictType(
-      this,
-      expectedValue.map((el) => `'${el}'`)
+      next,
+      expectedValue.map((el) => _quoteStringLiteral(el))
     );
-    return this.custom(oneOfValues(expectedValue));
+    return next;
   }
-  limitCheck() {
+  /**
+   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`
+   * returns, not on the one it was derived from.
+   */
+  limitGuard() {
     if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
-    this.limit = true;
   }
 };
 
 export {
-  string
+  string,
+  StringSchema
 };
-//# sourceMappingURL=chunk-UYQFYQQG.mjs.map
+//# sourceMappingURL=chunk-J3EKIWPZ.mjs.map

package/lib/chunk-J3EKIWPZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/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 { _quoteStringLiteral } from '../../helpers/quoteStringLiteral';\nimport { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description Creates a new schema for validating string values.\n * @returns {WithBGuardType<StringSchema, string>} A new instance of `StringSchema` for validating strings.\n * @example\n * const schema = string();\n * parseOrFail(schema, 'hello'); // Validates successfully\n * parseOrFail(schema, 123); // Throws a validation error\n *\n * @instance Of StringSchema\n */\nexport function string(): WithBGuardType<StringSchema, string> {\n  return new StringSchema({ type: ['string'], requiredValidations: [] }) as WithBGuardType<StringSchema, string>;\n}\n\nexport class StringSchema extends CommonSchema {\n  protected _string = 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 A new schema restricted to the specified value, with the literal value inferred as the TypeScript type\n   * @example\n   * string().equalTo('hello'); // Infers the type 'hello'\n   *\n   * @public\n   */\n  public equalTo<Y extends string>(expectedValue: Y): WithBGuardType<this, Y> {\n    this.limitGuard();\n    // custom() returns the copy, so the strict type and the once-only flag are set on it. Setting\n    // them on `this` first would refine the schema this one was derived from.\n    const next = this.custom(equalTo(expectedValue));\n    next.limit = true;\n    _setStrictType(next, _quoteStringLiteral(expectedValue));\n    return next 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 A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.\n   * @example\n   * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'\n   *\n   * @public\n   */\n  public oneOfValues<Y extends string>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    this.limitGuard();\n    const next = this.custom(oneOfValues(expectedValue));\n    next.limit = true;\n    _setStrictType(\n      next,\n      expectedValue.map((el) => _quoteStringLiteral(el)),\n    );\n    return next as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`\n   * returns, not on the one it was derived from.\n   */\n  private limitGuard() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAmBO,SAAS,SAA+C;AAC7D,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,QAAQ,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACvE;AAEO,IAAM,eAAN,cAA2B,aAAa;AAAA,EACnC,UAAU;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,QAA0B,eAA2C;AAC1E,SAAK,WAAW;AAGhB,UAAM,OAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAC/C,SAAK,QAAQ;AACb,mBAAe,MAAM,oBAAoB,aAAa,CAAC;AACvD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAA8B,eAA6C;AAChF,SAAK,WAAW;AAChB,UAAM,OAAO,KAAK,OAAO,YAAY,aAAa,CAAC;AACnD,SAAK,QAAQ;AACb;AAAA,MACE;AAAA,MACA,cAAc,IAAI,CAAC,OAAO,oBAAoB,EAAE,CAAC;AAAA,IACnD;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,aAAa;AACnB,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AAAA,EACtD;AACF;","names":[]}

package/lib/chunk-JCX2TB7E.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk4PPMVVQYjs = require('./chunk-4PPMVVQY.js');
+
+// src/asserts/coerce/number.ts
+var coerceNumber = () => _chunk4PPMVVQYjs.number.call(void 0, ).transformBeforeValidation(
+  (received) => received === null || typeof received === "number" ? received : Number(received)
+);
+
+
+
+exports.coerceNumber = coerceNumber;
+//# sourceMappingURL=chunk-JCX2TB7E.js.map

package/lib/chunk-JCX2TB7E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-JCX2TB7E.js","../src/asserts/coerce/number.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACqBO,IAAM,aAAA,EAAe,CAAA,EAAA,GAC1B,qCAAA,CAAO,CAAE,yBAAA;AAAA,EAAmC,CAAC,QAAA,EAAA,GAC3C,SAAA,IAAa,KAAA,GAAQ,OAAO,SAAA,IAAa,SAAA,EAAY,SAAA,EAAsB,MAAA,CAAO,QAAQ;AAC5F,CAAA;ADpBF;AACA;AACE;AACF,oCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-JCX2TB7E.js","sourcesContent":[null,"import { number } from '../number/index';\n\n/**\n * A coercing transform must never throw: it runs before validation, and throwing would replace a clear\n * validation error with an unexplained failure. Anything it cannot convert is passed through unchanged\n * so that validation reports the type problem itself.\n *\n * `null` is never coerced, so `nullable()` still decides whether it is allowed rather than it becoming\n * the string `'null'` or the number `0`.\n *\n * The return type is inferred rather than written out. Naming it flattened the schema to\n * `CommonSchema`, which silently dropped the methods only the concrete classes define — `equalTo`,\n * `oneOfValues`, `onlyTrue`, `onlyFalse`.\n */\n/**\n * @description Coerces the received value to a number before validating it. Anything that is not\n * already a number is passed through `Number`.\n *\n * A value `Number` cannot read becomes `NaN`, which `number()` rejects, so `'abc'` fails validation\n * rather than passing as a number.\n *\n * @returns A number schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceNumber(), '42'); // 42\n */\nexport const coerceNumber = () =>\n  number().transformBeforeValidation<unknown>((received) =>\n    received === null || typeof received === 'number' ? (received as number) : Number(received),\n  );\n"]}

package/lib/{chunk-2ESDKTV4.js → chunk-JF7KZZ7R.js}

@@ -1,18 +1,21 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // src/asserts/number/positive.ts
 var positiveErrorMessage = "The received value is not a positive number";
 var positiveErrorKey = "n:positive";
-var positive = () => (received, ctx) => {
-  if (received <= 0) ctx.addIssue("positive", received, positiveErrorMessage);
-};
+var positive = () => _chunkWOPNDC4Rjs._constrain.call(void 0, { exclusiveMinimum: 0 }, (received, ctx) => {
+  if (received <= 0) ctx.addIssue("positive", received, positiveErrorKey);
+});
 positive.key = positiveErrorKey;
 positive.message = positiveErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, positive);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, positive);
 
 
 
 exports.positive = positive;
-//# sourceMappingURL=chunk-2ESDKTV4.js.map
+//# sourceMappingURL=chunk-JF7KZZ7R.js.map

package/lib/chunk-JF7KZZ7R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-JF7KZZ7R.js","../src/asserts/number/positive.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,qBAAA,EAAuB,6CAAA;AAC7B,IAAM,iBAAA,EAAmB,YAAA;AAclB,IAAM,SAAA,EAAW,CAAA,EAAA,GACtB,yCAAA,EAAa,gBAAA,EAAkB,EAAE,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC/E,EAAA,GAAA,CAAI,SAAA,GAAY,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,UAAA,EAAY,QAAA,EAAU,gBAAgB,CAAA;AACxE,CAAC,CAAA;AAEH,QAAA,CAAS,IAAA,EAAM,gBAAA;AACf,QAAA,CAAS,QAAA,EAAU,oBAAA;AACnB,iDAAA,QAA2B,CAAA;ADV3B;AACA;AACE;AACF,4BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-JF7KZZ7R.js","sourcesContent":[null,"import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst positiveErrorMessage = 'The received value is not a positive number';\nconst positiveErrorKey = 'n:positive';\n\n/**\n * @description Asserts that a number value is positive (greater 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 positive.\n * @example\n * const schema = number().custom(positive());\n * parseOrFail(schema, 10);  // Valid\n * parseOrFail(schema, 0);  // Throws an error: 'The received value is not a positive number'\n * parseOrFail(schema, -5); // Throws an error: 'The received value is not a positive number'\n *\n * @translation Error Translation Key = 'n:positive'\n */\nexport const positive = (): RequiredValidation<number> =>\n  _constrain({ exclusiveMinimum: 0 }, (received: number, ctx: ExceptionContext) => {\n    if (received <= 0) ctx.addIssue('positive', received, positiveErrorKey);\n  });\n\npositive.key = positiveErrorKey;\npositive.message = positiveErrorMessage;\nsetToDefaultLocale(positive);\n"]}

package/lib/chunk-JHONMWCE.js

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkAO6DKPJZjs = require('./chunk-AO6DKPJZ.js');
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/asserts/object/omit.ts
+function omit(schema, keys) {
+  const shape = _chunkAO6DKPJZjs._shapeOf.call(void 0, schema, "omit");
+  const dropped = new Set(keys);
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(shape, key))
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Unknown property '${key}' in omit method`);
+  }
+  const kept = {};
+  for (const [key, valueSchema] of Object.entries(shape)) {
+    if (!dropped.has(key)) kept[key] = valueSchema;
+  }
+  return _chunkAO6DKPJZjs._objectFrom.call(void 0, schema, kept);
+}
+
+
+
+exports.omit = omit;
+//# sourceMappingURL=chunk-JHONMWCE.js.map

package/lib/chunk-JHONMWCE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-JHONMWCE.js","../src/asserts/object/omit.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACeO,SAAS,IAAA,CACd,MAAA,EACA,IAAA,EACsC;AACtC,EAAA,MAAM,MAAA,EAAQ,uCAAA,MAAS,EAAQ,MAAM,CAAA;AACrC,EAAA,MAAM,QAAA,EAAU,IAAI,GAAA,CAAY,IAAI,CAAA;AAEpC,EAAA,IAAA,CAAA,MAAW,IAAA,GAAO,IAAA,EAAM;AACtB,IAAA,GAAA,CAAI,CAAC,MAAA,CAAO,SAAA,CAAU,cAAA,CAAe,IAAA,CAAK,KAAA,EAAO,GAAG,CAAA;AAClD,MAAA,MAAM,IAAI,sCAAA,CAAiB,CAAA,kBAAA,EAAqB,GAAG,CAAA,gBAAA,CAAkB,CAAA;AAAA,EACzE;AAEA,EAAA,MAAM,KAAA,EAA8B,CAAC,CAAA;AACrC,EAAA,IAAA,CAAA,MAAW,CAAC,GAAA,EAAK,WAAW,EAAA,GAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AACtD,IAAA,GAAA,CAAI,CAAC,OAAA,CAAQ,GAAA,CAAI,GAAG,CAAA,EAAG,IAAA,CAAK,GAAG,EAAA,EAAI,WAAA;AAAA,EACrC;AAEA,EAAA,OAAO,0CAAA,MAAY,EAAQ,IAAI,CAAA;AACjC;ADnBA;AACA;AACE;AACF,oBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-JHONMWCE.js","sourcesContent":[null,"import { WithObject } from '../../commonTypes';\nimport { CommonSchema, ObjectShapeSchemaType } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ObjectSchema } from './index';\nimport { _objectFrom, _shapeOf } from './pick';\n\n/**\n * @description Creates a new object schema without the named properties.\n *\n * The original is untouched.\n *\n * @template T\n * @template K\n * @param {WithObject<CommonSchema, T>} schema - The object schema to narrow.\n * @param {readonly K[]} keys - The properties to drop.\n * @returns A new object schema without those properties.\n * @example\n * const userSchema = object({ id: string(), name: string(), secret: string() });\n * const publicSchema = omit(userSchema, ['secret']);\n * parseOrFail(publicSchema, { id: '1', name: 'a' }); // Validates successfully\n *\n * @instance Of CommonSchema\n */\nexport function omit<T extends ObjectShapeSchemaType, K extends keyof T & string>(\n  schema: WithObject<CommonSchema, T>,\n  keys: readonly K[],\n): WithObject<ObjectSchema, Omit<T, K>> {\n  const shape = _shapeOf(schema, 'omit');\n  const dropped = new Set<string>(keys);\n\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(shape, key))\n      throw new BuildSchemaError(`Unknown property '${key}' in omit method`);\n  }\n\n  const kept: ObjectShapeSchemaType = {};\n  for (const [key, valueSchema] of Object.entries(shape)) {\n    if (!dropped.has(key)) kept[key] = valueSchema;\n  }\n\n  return _objectFrom(schema, kept) as unknown as WithObject<ObjectSchema, Omit<T, K>>;\n}\n"]}

package/lib/{chunk-DED5KDLM.js → chunk-JLEQOYDW.js}

@@ -1,27 +1,27 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
 
-var _chunkVN4GLOENjs = require('./chunk-VN4GLOEN.js');
+var _chunk6LUSV3SSjs = require('./chunk-6LUSV3SS.js');
 
 
-var _chunkFIDPCCCWjs = require('./chunk-FIDPCCCW.js');
+var _chunkLHEU4XACjs = require('./chunk-LHEU4XAC.js');
 
 
-var _chunkAXKX5BGHjs = require('./chunk-AXKX5BGH.js');
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
 
 // src/asserts/object/index.ts
-var ObjectSchema = (_class = class extends _chunkVN4GLOENjs.CommonSchema {
+var ObjectSchema = (_class = class extends _chunk6LUSV3SSjs.CommonSchema {
   __init() {this._object = 1}
   constructor(ctx, shapeSchema) {
     super(ctx);_class.prototype.__init.call(this);;
     this.validateObjectEntry(shapeSchema);
-    this[_chunkAXKX5BGHjs.ctxSymbol].object = shapeSchema;
+    this[_chunkLHEU4XACjs.ctxSymbol].object = shapeSchema;
   }
   validateObjectEntry(shapeSchema) {
-    if (!shapeSchema) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Missing schema in object method");
-    if (shapeSchema instanceof _chunkVN4GLOENjs.CommonSchema) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid schema in object");
+    if (!shapeSchema) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Missing schema in object method");
+    if (shapeSchema instanceof _chunk6LUSV3SSjs.CommonSchema) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Invalid schema in object");
     for (const [key, value] of Object.entries(shapeSchema)) {
-      if (!(value instanceof _chunkVN4GLOENjs.CommonSchema))
-        throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)(`Invalid schema in object method for property '${key}'`);
+      if (!(value instanceof _chunk6LUSV3SSjs.CommonSchema))
+        throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Invalid schema in object method for property '${key}'`);
     }
   }
   /**
@@ -43,8 +43,9 @@ var ObjectSchema = (_class = class extends _chunkVN4GLOENjs.CommonSchema {
    * @public
    */
   allowUnrecognized() {
-    this[_chunkAXKX5BGHjs.ctxSymbol].allowUnrecognizedObjectProps = true;
-    return this;
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].allowUnrecognizedObjectProps = true;
+    return next;
   }
 }, _class);
 function object(shapeSchema) {
@@ -53,5 +54,6 @@ function object(shapeSchema) {
 
 
 
-exports.object = object;
-//# sourceMappingURL=chunk-DED5KDLM.js.map
+
+exports.ObjectSchema = ObjectSchema; exports.object = object;
+//# sourceMappingURL=chunk-JLEQOYDW.js.map

package/lib/chunk-JLEQOYDW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-JLEQOYDW.js","../src/asserts/object/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACLO,IAAM,aAAA,YAAN,MAAA,QAA2B,8BAAa;AAAA,iBACnC,QAAA,EAAU,EAAA;AAAA,EACpB,WAAA,CAAY,GAAA,EAAuB,WAAA,EAAoC;AACrE,IAAA,KAAA,CAAM,GAAG,qCAAA;AACT,IAAA,IAAA,CAAK,mBAAA,CAAoB,WAAW,CAAA;AACpC,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,OAAA,EAAS,WAAA;AAAA,EAC3B;AAAA,EAEQ,mBAAA,CAAoB,WAAA,EAAoC;AAC9D,IAAA,GAAA,CAAI,CAAC,WAAA,EAAa,MAAM,IAAI,sCAAA,CAAiB,iCAAiC,CAAA;AAC9E,IAAA,GAAA,CAAI,YAAA,WAAuB,6BAAA,EAAc,MAAM,IAAI,sCAAA,CAAiB,0BAA0B,CAAA;AAC9F,IAAA,IAAA,CAAA,MAAW,CAAC,GAAA,EAAK,KAAK,EAAA,GAAK,MAAA,CAAO,OAAA,CAAQ,WAAW,CAAA,EAAG;AACtD,MAAA,GAAA,CAAI,CAAA,CAAE,MAAA,WAAiB,6BAAA,CAAA;AACrB,QAAA,MAAM,IAAI,sCAAA,CAAiB,CAAA,8CAAA,EAAiD,GAAG,CAAA,CAAA,CAAG,CAAA;AAAA,IACtF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,iBAAA,CAAA,EAA0B;AAC/B,IAAA,MAAM,KAAA,EAAO,IAAA,CAAK,KAAA,CAAM,CAAA;AACxB,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,6BAAA,EAA+B,IAAA;AAC/C,IAAA,OAAO,IAAA;AAAA,EACT;AACF,UAAA;AAiBO,SAAS,MAAA,CAAwC,WAAA,EAA6C;AACnG,EAAA,OAAO,IAAI,YAAA,CAAa,EAAE,IAAA,EAAM,CAAC,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAA,EAAG,WAAW,CAAA;AAC5E;ADXA;AACA;AACE;AACA;AACF,6DAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-JLEQOYDW.js","sourcesContent":[null,"import { WithObject } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ctxSymbol } from '../../helpers/constants';\nimport { CommonSchema, ValidatorContext, type ObjectShapeSchemaType } from '../../core';\n\nexport class 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    const next = this.clone();\n    next[ctxSymbol].allowUnrecognizedObjectProps = true;\n    return next;\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"]}

package/lib/{chunk-HD37VXPZ.mjs → chunk-JND3VAPR.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/atLeastOneDigit.ts
 var digitRegExp = /\d/;
@@ -16,4 +16,4 @@ setToDefaultLocale(atLeastOneDigit);
 export {
   atLeastOneDigit
 };
-//# sourceMappingURL=chunk-HD37VXPZ.mjs.map
+//# sourceMappingURL=chunk-JND3VAPR.mjs.map

package/lib/{chunk-HD37VXPZ.mjs.map → chunk-JND3VAPR.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/atLeastOneDigit.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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)) ctx.addIssue('at least one digit', received, atLeastOneDigitErrorKey);\n};\n\natLeastOneDigit.key = atLeastOneDigitErrorKey;\natLeastOneDigit.message = atLeastOneDigitErrorMessage;\nsetToDefaultLocale(atLeastOneDigit);\n"],"mappings":";;;;;AAGA,IAAM,cAAc;AACpB,IAAM,8BAA8B;AACpC,IAAM,0BAA0B;AAazB,IAAM,kBAAkB,MAA0B,CAAC,UAAkB,QAA0B;AACpG,MAAI,CAAC,YAAY,KAAK,QAAQ,EAAG,KAAI,SAAS,sBAAsB,UAAU,uBAAuB;AACvG;AAEA,gBAAgB,MAAM;AACtB,gBAAgB,UAAU;AAC1B,mBAAmB,eAAe;","names":[]}
+{"version":3,"sources":["../src/asserts/string/atLeastOneDigit.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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<string> => (received: string, ctx: ExceptionContext) => {\n  if (!digitRegExp.test(received)) ctx.addIssue('at least one digit', received, atLeastOneDigitErrorKey);\n};\n\natLeastOneDigit.key = atLeastOneDigitErrorKey;\natLeastOneDigit.message = atLeastOneDigitErrorMessage;\nsetToDefaultLocale(atLeastOneDigit);\n"],"mappings":";;;;;AAGA,IAAM,cAAc;AACpB,IAAM,8BAA8B;AACpC,IAAM,0BAA0B;AAazB,IAAM,kBAAkB,MAAkC,CAAC,UAAkB,QAA0B;AAC5G,MAAI,CAAC,YAAY,KAAK,QAAQ,EAAG,KAAI,SAAS,sBAAsB,UAAU,uBAAuB;AACvG;AAEA,gBAAgB,MAAM;AACtB,gBAAgB,UAAU;AAC1B,mBAAmB,eAAe;","names":[]}

package/lib/chunk-K4YXIN2V.mjs

@@ -0,0 +1,33 @@
+// src/formatErrors.ts
+function flattenErrors(errors) {
+  const flat = { formErrors: [], fieldErrors: {} };
+  for (const error of errors) {
+    const [field] = error.path;
+    if (field === void 0) {
+      flat.formErrors.push(error.message);
+      continue;
+    }
+    const key = String(field);
+    (flat.fieldErrors[key] ??= []).push(error.message);
+  }
+  return flat;
+}
+function treeifyErrors(errors) {
+  const root = { errors: [] };
+  for (const error of errors) {
+    let node = root;
+    for (const segment of error.path) {
+      node.properties ??= {};
+      node.properties[String(segment)] ??= { errors: [] };
+      node = node.properties[String(segment)];
+    }
+    node.errors.push(error.message);
+  }
+  return root;
+}
+
+export {
+  flattenErrors,
+  treeifyErrors
+};
+//# sourceMappingURL=chunk-K4YXIN2V.mjs.map

package/lib/chunk-K4YXIN2V.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/formatErrors.ts"],"sourcesContent":["import type { ValidationErrorData } from './commonTypes';\n\nexport interface FlatErrors {\n  /** Messages for failures at the root, which belong to no single field. */\n  formErrors: string[];\n  /** Messages by the first key of their path, which is what a flat form binds to. */\n  fieldErrors: Record<string, string[]>;\n}\n\n/**\n * Groups errors by their top-level field, the shape a flat form needs.\n *\n * A failure deeper in the structure is attributed to the field it sits under, so a form bound to\n * `address` still sees a message that came from `address.street`.\n *\n * @example\n * const [errors] = parse(schema, received, { getAllErrors: true });\n * if (errors) {\n *   const { formErrors, fieldErrors } = flattenErrors(errors);\n * }\n */\nexport function flattenErrors(errors: readonly ValidationErrorData[]): FlatErrors {\n  const flat: FlatErrors = { formErrors: [], fieldErrors: {} };\n\n  for (const error of errors) {\n    const [field] = error.path;\n\n    if (field === undefined) {\n      flat.formErrors.push(error.message);\n      continue;\n    }\n\n    const key = String(field);\n    (flat.fieldErrors[key] ??= []).push(error.message);\n  }\n\n  return flat;\n}\n\nexport interface ErrorTree {\n  /** Messages belonging to this node itself. */\n  errors: string[];\n  /** Child nodes, keyed the way the received value is. Absent when this node has no children. */\n  properties?: Record<string, ErrorTree>;\n}\n\n/**\n * Rebuilds the errors as a tree mirroring the received value, for a form whose fields are nested.\n *\n * Array and tuple indexes become their string form, since a tree is keyed by strings either way and\n * the original key is still available on the error itself.\n *\n * @example\n * const tree = treeifyErrors(errors);\n * tree.properties?.address?.properties?.street?.errors;\n */\nexport function treeifyErrors(errors: readonly ValidationErrorData[]): ErrorTree {\n  const root: ErrorTree = { errors: [] };\n\n  for (const error of errors) {\n    let node = root;\n\n    for (const segment of error.path) {\n      node.properties ??= {};\n      node.properties[String(segment)] ??= { errors: [] };\n      node = node.properties[String(segment)] as ErrorTree;\n    }\n\n    node.errors.push(error.message);\n  }\n\n  return root;\n}\n"],"mappings":";AAqBO,SAAS,cAAc,QAAoD;AAChF,QAAM,OAAmB,EAAE,YAAY,CAAC,GAAG,aAAa,CAAC,EAAE;AAE3D,aAAW,SAAS,QAAQ;AAC1B,UAAM,CAAC,KAAK,IAAI,MAAM;AAEtB,QAAI,UAAU,QAAW;AACvB,WAAK,WAAW,KAAK,MAAM,OAAO;AAClC;AAAA,IACF;AAEA,UAAM,MAAM,OAAO,KAAK;AACxB,KAAC,KAAK,YAAY,GAAG,MAAM,CAAC,GAAG,KAAK,MAAM,OAAO;AAAA,EACnD;AAEA,SAAO;AACT;AAmBO,SAAS,cAAc,QAAmD;AAC/E,QAAM,OAAkB,EAAE,QAAQ,CAAC,EAAE;AAErC,aAAW,SAAS,QAAQ;AAC1B,QAAI,OAAO;AAEX,eAAW,WAAW,MAAM,MAAM;AAChC,WAAK,eAAe,CAAC;AACrB,WAAK,WAAW,OAAO,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;AAClD,aAAO,KAAK,WAAW,OAAO,OAAO,CAAC;AAAA,IACxC;AAEA,SAAK,OAAO,KAAK,MAAM,OAAO;AAAA,EAChC;AAEA,SAAO;AACT;","names":[]}

package/lib/{chunk-NY2TPU6O.mjs → chunk-K6QYFFMX.mjs}

@@ -1,13 +1,16 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.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);
-};
+var maxArrayLength = (expected) => _constrain({ maxItems: expected }, (received, ctx) => {
+  if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorKey);
+});
 maxArrayLength.key = maxArrayLengthErrorKey;
 maxArrayLength.message = maxArrayLengthErrorMessage;
 setToDefaultLocale(maxArrayLength);
@@ -15,4 +18,4 @@ setToDefaultLocale(maxArrayLength);
 export {
   maxArrayLength
 };
-//# sourceMappingURL=chunk-NY2TPU6O.mjs.map
+//# sourceMappingURL=chunk-K6QYFFMX.mjs.map

package/lib/chunk-K6QYFFMX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/array/maxArrayLength.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\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 = (expected: number): RequiredValidation<unknown[]> =>\n  _constrain({ maxItems: expected }, (received: unknown[], ctx: ExceptionContext) => {\n    if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorKey);\n  });\n\nmaxArrayLength.key = maxArrayLengthErrorKey;\nmaxArrayLength.message = maxArrayLengthErrorMessage;\nsetToDefaultLocale(maxArrayLength);\n"],"mappings":";;;;;;;;AAIA,IAAM,6BAA6B;AACnC,IAAM,yBAAyB;AAexB,IAAM,iBAAiB,CAAC,aAC7B,WAAW,EAAE,UAAU,SAAS,GAAG,CAAC,UAAqB,QAA0B;AACjF,MAAI,SAAS,SAAS,SAAU,KAAI,SAAS,UAAU,UAAU,sBAAsB;AACzF,CAAC;AAEH,eAAe,MAAM;AACrB,eAAe,UAAU;AACzB,mBAAmB,cAAc;","names":[]}

package/lib/chunk-K7CDOU6F.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkYPOEO3UFjs = require('./chunk-YPOEO3UF.js');
+
+// src/asserts/coerce/date.ts
+var coerceDate = () => _chunkYPOEO3UFjs.date.call(void 0, ).transformBeforeValidation(
+  (received) => received === null || received instanceof Date ? received : new Date(received)
+);
+
+
+
+exports.coerceDate = coerceDate;
+//# sourceMappingURL=chunk-K7CDOU6F.js.map

package/lib/chunk-K7CDOU6F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-K7CDOU6F.js","../src/asserts/coerce/date.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACoBO,IAAM,WAAA,EAAa,CAAA,EAAA,GACxB,mCAAA,CAAK,CAAE,yBAAA;AAAA,EAAmC,CAAC,QAAA,EAAA,GACzC,SAAA,IAAa,KAAA,GAAQ,SAAA,WAAoB,KAAA,EAAQ,SAAA,EAAoB,IAAI,IAAA,CAAK,QAAkB;AAClG,CAAA;ADnBF;AACA;AACE;AACF,gCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-K7CDOU6F.js","sourcesContent":[null,"import { date } from '../date/index';\n\n/**\n * A coercing transform must never throw: it runs before validation, and throwing would replace a clear\n * validation error with an unexplained failure. Anything it cannot convert is passed through unchanged\n * so that validation reports the type problem itself.\n *\n * `null` is never coerced, so `nullable()` still decides whether it is allowed rather than it becoming\n * the string `'null'` or the number `0`.\n *\n * The return type is inferred rather than written out. Naming it flattened the schema to\n * `CommonSchema`, which silently dropped the methods only the concrete classes define — `equalTo`,\n * `oneOfValues`, `onlyTrue`, `onlyFalse`.\n */\n/**\n * @description Coerces the received value to a Date before validating it. Anything that is not already\n * a Date is passed through `new Date`.\n *\n * An unreadable value becomes an invalid Date, which `date()` rejects.\n *\n * @returns A date schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceDate(), '2024-01-01'); // Date\n */\nexport const coerceDate = () =>\n  date().transformBeforeValidation<unknown>((received) =>\n    received === null || received instanceof Date ? (received as Date) : new Date(received as string),\n  );\n"]}

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

@@ -1,12 +1,12 @@
 import {
   CommonSchema
-} from "./chunk-QIPGUTIG.mjs";
-import {
-  BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-LDZFOOWN.mjs";
 import {
   ctxSymbol
-} from "./chunk-2ANPCB4O.mjs";
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
 
 // src/asserts/object/index.ts
 var ObjectSchema = class extends CommonSchema {
@@ -43,8 +43,9 @@ var ObjectSchema = class extends CommonSchema {
    * @public
    */
   allowUnrecognized() {
-    this[ctxSymbol].allowUnrecognizedObjectProps = true;
-    return this;
+    const next = this.clone();
+    next[ctxSymbol].allowUnrecognizedObjectProps = true;
+    return next;
   }
 };
 function object(shapeSchema) {
@@ -52,6 +53,7 @@ function object(shapeSchema) {
 }
 
 export {
+  ObjectSchema,
   object
 };
-//# sourceMappingURL=chunk-M3HYPZLE.mjs.map
+//# sourceMappingURL=chunk-KAFZGQ2W.mjs.map

package/lib/chunk-KAFZGQ2W.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\nexport class 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    const next = this.clone();\n    next[ctxSymbol].allowUnrecognizedObjectProps = true;\n    return next;\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":";;;;;;;;;;;AAKO,IAAM,eAAN,cAA2B,aAAa;AAAA,EACnC,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,UAAM,OAAO,KAAK,MAAM;AACxB,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-KALHMMEN.mjs

@@ -0,0 +1,29 @@
+import {
+  coerceBigInt
+} from "./chunk-ET2I4EXQ.mjs";
+import {
+  coerceBoolean
+} from "./chunk-FA3S35LQ.mjs";
+import {
+  coerceDate
+} from "./chunk-MUXY6Q45.mjs";
+import {
+  coerceNumber
+} from "./chunk-UCY3HEYZ.mjs";
+import {
+  coerceString
+} from "./chunk-SBNUNRI3.mjs";
+
+// src/asserts/coerce/index.ts
+var coerce = {
+  string: coerceString,
+  number: coerceNumber,
+  boolean: coerceBoolean,
+  bigint: coerceBigInt,
+  date: coerceDate
+};
+
+export {
+  coerce
+};
+//# sourceMappingURL=chunk-KALHMMEN.mjs.map

package/lib/chunk-KALHMMEN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/coerce/index.ts"],"sourcesContent":["import { coerceBigInt } from './bigint';\nimport { coerceBoolean } from './boolean';\nimport { coerceDate } from './date';\nimport { coerceNumber } from './number';\nimport { coerceString } from './string';\n\nexport { coerceBigInt } from './bigint';\nexport { coerceBoolean } from './boolean';\nexport { coerceDate } from './date';\nexport { coerceNumber } from './number';\nexport { coerceString } from './string';\n\n/**\n * The coercing schemas gathered under one name, for when reaching for several of them reads better than\n * five imports.\n *\n * Note that this object references all five, so a bundler has to keep all five wherever it is used —\n * importing it for `coerce.number()` alone still pulls in the string, boolean, bigint and date schemas.\n * Import the one you need from its own module when that matters:\n *\n * ```typescript\n * import { coerceNumber } from 'bguard/coerce/number';\n * ```\n *\n * @example\n * const querySchema = object({ page: coerce.number().default(1), q: coerce.string() });\n * parseOrFail(querySchema, { page: '3', q: 'shoes' }); // { page: 3, q: 'shoes' }\n */\nexport const coerce = {\n  string: coerceString,\n  number: coerceNumber,\n  boolean: coerceBoolean,\n  bigint: coerceBigInt,\n  date: coerceDate,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AA4BO,IAAM,SAAS;AAAA,EACpB,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,MAAM;AACR;","names":[]}

package/lib/{chunk-DFYP4GKE.js → chunk-KDPYWGMJ.js}

@@ -1,21 +1,24 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // 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) => {
+var maxKeys = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { maxProperties: expected }, (receivedObject, ctx) => {
   const keysCount = Object.keys(receivedObject).length;
   if (keysCount > expected) {
     ctx.addIssue(expected, keysCount, maxKeysErrorKey);
   }
-};
+});
 maxKeys.key = maxKeysErrorKey;
 maxKeys.message = maxKeysErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, maxKeys);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, maxKeys);
 
 
 
 exports.maxKeys = maxKeys;
-//# sourceMappingURL=chunk-DFYP4GKE.js.map
+//# sourceMappingURL=chunk-KDPYWGMJ.js.map

package/lib/chunk-KDPYWGMJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-KDPYWGMJ.js","../src/asserts/object/maxKeys.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,oBAAA,EAAsB,sDAAA;AAC5B,IAAM,gBAAA,EAAkB,WAAA;AAuBjB,IAAM,QAAA,EAAU,CAAC,QAAA,EAAA,GACtB,yCAAA,EAAa,aAAA,EAAe,SAAS,CAAA,EAAG,CAAC,cAAA,EAAyC,GAAA,EAAA,GAA0B;AAC1G,EAAA,MAAM,UAAA,EAAY,MAAA,CAAO,IAAA,CAAK,cAAc,CAAA,CAAE,MAAA;AAC9C,EAAA,GAAA,CAAI,UAAA,EAAY,QAAA,EAAU;AACxB,IAAA,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,SAAA,EAAW,eAAe,CAAA;AAAA,EACnD;AACF,CAAC,CAAA;AAEH,OAAA,CAAQ,IAAA,EAAM,eAAA;AACd,OAAA,CAAQ,QAAA,EAAU,mBAAA;AAClB,iDAAA,OAA0B,CAAA;ADnB1B;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-KDPYWGMJ.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\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 = (expected: number): RequiredValidation<Record<string, unknown>> =>\n  _constrain({ maxProperties: expected }, (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"]}

package/lib/chunk-KGXWQ3XP.mjs

@@ -0,0 +1,69 @@
+import {
+  _setStrictType
+} from "./chunk-IIL6D2UL.mjs";
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  ONLY_ONCE
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/boolean/index.ts
+var isBoolean = (expected) => (received, ctx) => {
+  if (received !== expected) ctx.addIssue(expected, received, "c:isBoolean");
+};
+function boolean() {
+  return new BooleanSchema({ type: ["boolean"], requiredValidations: [] });
+}
+var BooleanSchema = class extends CommonSchema {
+  _boolean = 1;
+  limit;
+  /**
+   * Reads the once-only flag without setting it, matching the string, number and bigint schemas.
+   * Without it, onlyTrue().onlyFalse() built a schema that rejects both true and false.
+   */
+  limitGuard() {
+    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
+  }
+  /**
+   * @method onlyTrue
+   * @description Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+   * @returns A new schema restricted to the value true, with the true value inferred as the TypeScript type
+   * @example
+   * boolean().onlyTrue(); // Infers the type true
+   *
+   * @public
+   */
+  onlyTrue() {
+    this.limitGuard();
+    const next = this.custom(isBoolean(true));
+    next.limit = true;
+    _setStrictType(next, true);
+    return next;
+  }
+  /**
+   * @method onlyFalse
+   * @description Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+   * @returns A new schema restricted to the value false, with the false value inferred as the TypeScript type
+   * @example
+   * boolean().onlyFalse(); // Infers the type false
+   *
+   * @public
+   */
+  onlyFalse() {
+    this.limitGuard();
+    const next = this.custom(isBoolean(false));
+    next.limit = true;
+    _setStrictType(next, false);
+    return next;
+  }
+};
+
+export {
+  boolean,
+  BooleanSchema
+};
+//# sourceMappingURL=chunk-KGXWQ3XP.mjs.map

package/lib/chunk-KGXWQ3XP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/boolean/index.ts"],"sourcesContent":["import { WithBGuardType } from '../../commonTypes';\nimport { CommonSchema, type ExceptionContext, type RequiredValidation } from '../../core';\nimport { _setStrictType } from '../../helpers/setStrictType';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ONLY_ONCE } from '../../helpers/constants';\n\n// Declared over `unknown` rather than `boolean`: it is applied from inside the class, where `this`\n// is still polymorphic, so the schema's own value type cannot be resolved yet. The comparison is\n// identity-based, so widening the parameter costs nothing.\nconst isBoolean =\n  (expected: boolean): RequiredValidation<unknown> =>\n  (received: unknown, ctx: ExceptionContext) => {\n    if (received !== expected) ctx.addIssue(expected, received, 'c:isBoolean');\n  };\n\n/**\n * @description Creates a new schema for validating boolean values.\n * @returns {WithBGuardType<BooleanSchema, boolean>} A new instance of `BooleanSchema` for validating booleans.\n * @example\n * const schema = boolean();\n * parseOrFail(schema, true); // Validates successfully\n * parseOrFail(schema, 'true'); // Throws a validation error\n *\n * @instance Of BooleanSchema\n */\nexport function boolean(): WithBGuardType<BooleanSchema, boolean> {\n  return new BooleanSchema({ type: ['boolean'], requiredValidations: [] }) as WithBGuardType<BooleanSchema, boolean>;\n}\n\nexport class BooleanSchema extends CommonSchema {\n  protected _boolean = 1;\n  private limit: boolean | undefined;\n\n  /**\n   * Reads the once-only flag without setting it, matching the string, number and bigint schemas.\n   * Without it, onlyTrue().onlyFalse() built a schema that rejects both true and false.\n   */\n  private limitGuard() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n  }\n\n  /**\n   * @method onlyTrue\n   * @description Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.\n   * @returns A new schema restricted to the value true, with the true value inferred as the TypeScript type\n   * @example\n   * boolean().onlyTrue(); // Infers the type true\n   *\n   * @public\n   */\n  public onlyTrue(): WithBGuardType<this, true> {\n    this.limitGuard();\n    const next = this.custom(isBoolean(true));\n    next.limit = true;\n    _setStrictType(next, true);\n    return next as WithBGuardType<this, true>;\n  }\n\n  /**\n   * @method onlyFalse\n   * @description Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.\n   * @returns A new schema restricted to the value false, with the false value inferred as the TypeScript type\n   * @example\n   * boolean().onlyFalse(); // Infers the type false\n   *\n   * @public\n   */\n  public onlyFalse(): WithBGuardType<this, false> {\n    this.limitGuard();\n    const next = this.custom(isBoolean(false));\n    next.limit = true;\n    _setStrictType(next, false);\n    return next as WithBGuardType<this, false>;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AASA,IAAM,YACJ,CAAC,aACD,CAAC,UAAmB,QAA0B;AAC5C,MAAI,aAAa,SAAU,KAAI,SAAS,UAAU,UAAU,aAAa;AAC3E;AAYK,SAAS,UAAkD;AAChE,SAAO,IAAI,cAAc,EAAE,MAAM,CAAC,SAAS,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACzE;AAEO,IAAM,gBAAN,cAA4B,aAAa;AAAA,EACpC,WAAW;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa;AACnB,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,WAAuC;AAC5C,SAAK,WAAW;AAChB,UAAM,OAAO,KAAK,OAAO,UAAU,IAAI,CAAC;AACxC,SAAK,QAAQ;AACb,mBAAe,MAAM,IAAI;AACzB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,YAAyC;AAC9C,SAAK,WAAW;AAChB,UAAM,OAAO,KAAK,OAAO,UAAU,KAAK,CAAC;AACzC,SAAK,QAAQ;AACb,mBAAe,MAAM,KAAK;AAC1B,WAAO;AAAA,EACT;AACF;","names":[]}

package/lib/{chunk-R25HSJPH.js → chunk-KIVIWBIY.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // src/asserts/string/uuidV4.ts
 var uuidV4ErrorMessage = "The received value is not a valid UUID v4";
@@ -13,9 +13,9 @@ var uuidV4 = () => (received, ctx) => {
 };
 uuidV4.key = uuidV4ErrorKey;
 uuidV4.message = uuidV4ErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, uuidV4);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, uuidV4);
 
 
 
 exports.uuidV4 = uuidV4;
-//# sourceMappingURL=chunk-R25HSJPH.js.map
+//# sourceMappingURL=chunk-KIVIWBIY.js.map