bguard 0.5.0 → 0.7.0

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-K6QYFFMX.mjs

@@ -0,0 +1,21 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
+import {
+  setToDefaultLocale
+} 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) => _constrain({ maxItems: expected }, (received, ctx) => {
+  if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorKey);
+});
+maxArrayLength.key = maxArrayLengthErrorKey;
+maxArrayLength.message = maxArrayLengthErrorMessage;
+setToDefaultLocale(maxArrayLength);
+
+export {
+  maxArrayLength
+};
+//# 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-CCNK27CX.mjs → chunk-KAFZGQ2W.mjs}

@@ -1,14 +1,14 @@
 import {
   CommonSchema
-} from "./chunk-UEYMBPZN.mjs";
+} from "./chunk-LDZFOOWN.mjs";
 import {
   ctxSymbol
-} from "./chunk-MQRXWXHP.mjs";
+} from "./chunk-C76DLZFD.mjs";
 import {
   BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-O2WD4JBG.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,21 @@ var ObjectSchema = class extends CommonSchema {
    *
    * parseOrFail(userSchema, ({ name: 'John', age: 30, extra: 'value' }););
    * //  No error thrown
+   *
+   * @public
    */
   allowUnrecognized() {
-    this[ctxSymbol].allowUnrecognizedObjectProps = true;
-    return this;
+    const next = this.clone();
+    next[ctxSymbol].allowUnrecognizedObjectProps = true;
+    return next;
   }
 };
+function object(shapeSchema) {
+  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema);
+}
 
 export {
-  ObjectSchema
+  ObjectSchema,
+  object
 };
-//# sourceMappingURL=chunk-CCNK27CX.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-KDPYWGMJ.js

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+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) => _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;
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, maxKeys);
+
+
+
+exports.maxKeys = maxKeys;
+//# 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-KGNT5T35.mjs

@@ -0,0 +1,70 @@
+import {
+  string
+} from "./chunk-YJZXJKM4.mjs";
+import {
+  number
+} from "./chunk-CJCIOMS7.mjs";
+import {
+  date
+} from "./chunk-O646PJXY.mjs";
+import {
+  bigint
+} from "./chunk-UWONIZJZ.mjs";
+import {
+  boolean
+} from "./chunk-5VZDHJKM.mjs";
+
+// src/asserts/coerce/index.ts
+var coerce = {
+  /** Anything that is not already a string is passed through `String`. */
+  string: () => string().transformBeforeValidation(
+    (received) => received === null || typeof received === "string" ? received : String(received)
+  ),
+  /**
+   * Anything that is not already a number is passed through `Number`. A value `Number` cannot read
+   * becomes `NaN`, which `number()` rejects, so `'abc'` fails validation rather than passing as a
+   * number.
+   */
+  number: () => number().transformBeforeValidation(
+    (received) => received === null || typeof received === "number" ? received : Number(received)
+  ),
+  /**
+   * Only the values that unambiguously mean a boolean are converted: the strings `'true'` and
+   * `'false'` in any case, and the numbers `1` and `0`. Everything else is left for validation to
+   * reject.
+   *
+   * Deliberately narrower than passing the value through `Boolean`, which would accept every input
+   * and quietly read `'false'` as `true`.
+   */
+  boolean: () => boolean().transformBeforeValidation((received) => {
+    if (typeof received === "string") {
+      const lowered = received.toLowerCase();
+      if (lowered === "true") return true;
+      if (lowered === "false") return false;
+    }
+    if (received === 1) return true;
+    if (received === 0) return false;
+    return received;
+  }),
+  /** `BigInt` throws on a value it cannot read, so the original is kept for validation to reject. */
+  bigint: () => bigint().transformBeforeValidation((received) => {
+    if (received === null || typeof received === "bigint") return received;
+    try {
+      return BigInt(received);
+    } catch {
+      return received;
+    }
+  }),
+  /**
+   * Anything that is not already a Date is passed through `new Date`. An unreadable value becomes an
+   * invalid Date, which `date()` rejects.
+   */
+  date: () => date().transformBeforeValidation(
+    (received) => received === null || received instanceof Date ? received : new Date(received)
+  )
+};
+
+export {
+  coerce
+};
+//# sourceMappingURL=chunk-KGNT5T35.mjs.map

package/lib/chunk-KGNT5T35.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/coerce/index.ts"],"sourcesContent":["import { WithBGuardType, WithInput } from '../../commonTypes';\nimport { CommonSchema } from '../../core';\nimport { bigint } from '../bigint/index';\nimport { boolean } from '../boolean/index';\nimport { date } from '../date/index';\nimport { number } from '../number/index';\nimport { string } from '../string/index';\n\n/**\n * A coercing transform must never throw: it runs before validation, and throwing would replace a\n * clear validation error with an unexplained failure. Anything it cannot convert is passed through\n * unchanged so that validation reports the type problem itself.\n */\ntype Coerced<S, In> = WithInput<S, In>;\n\n/**\n * Converts the received value before validating it, for input that does not arrive already typed —\n * query strings, form data, environment variables.\n *\n * Each of these accepts `unknown` and reports that in its inferred input type, while the output type\n * is unchanged. `null` is left alone, so `nullable()` still decides whether it is allowed rather than\n * being turned into the string `'null'` or the number `0`.\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  /** Anything that is not already a string is passed through `String`. */\n  string: (): Coerced<WithBGuardType<CommonSchema, string>, unknown> =>\n    string().transformBeforeValidation<unknown>((received) =>\n      received === null || typeof received === 'string' ? (received as string) : String(received),\n    ) as unknown as Coerced<WithBGuardType<CommonSchema, string>, unknown>,\n\n  /**\n   * Anything that is not already a number is passed through `Number`. A value `Number` cannot read\n   * becomes `NaN`, which `number()` rejects, so `'abc'` fails validation rather than passing as a\n   * number.\n   */\n  number: (): Coerced<WithBGuardType<CommonSchema, number>, unknown> =>\n    number().transformBeforeValidation<unknown>((received) =>\n      received === null || typeof received === 'number' ? (received as number) : Number(received),\n    ) as unknown as Coerced<WithBGuardType<CommonSchema, number>, unknown>,\n\n  /**\n   * Only the values that unambiguously mean a boolean are converted: the strings `'true'` and\n   * `'false'` in any case, and the numbers `1` and `0`. Everything else is left for validation to\n   * reject.\n   *\n   * Deliberately narrower than passing the value through `Boolean`, which would accept every input\n   * and quietly read `'false'` as `true`.\n   */\n  boolean: (): Coerced<WithBGuardType<CommonSchema, boolean>, unknown> =>\n    boolean().transformBeforeValidation<unknown>((received) => {\n      if (typeof received === 'string') {\n        const lowered = received.toLowerCase();\n        if (lowered === 'true') return true;\n        if (lowered === 'false') return false;\n      }\n\n      if (received === 1) return true;\n      if (received === 0) return false;\n\n      return received as boolean;\n    }) as unknown as Coerced<WithBGuardType<CommonSchema, boolean>, unknown>,\n\n  /** `BigInt` throws on a value it cannot read, so the original is kept for validation to reject. */\n  bigint: (): Coerced<WithBGuardType<CommonSchema, bigint>, unknown> =>\n    bigint().transformBeforeValidation<unknown>((received) => {\n      if (received === null || typeof received === 'bigint') return received as bigint;\n\n      try {\n        return BigInt(received as string | number);\n      } catch {\n        return received as bigint;\n      }\n    }) as unknown as Coerced<WithBGuardType<CommonSchema, bigint>, unknown>,\n\n  /**\n   * Anything that is not already a Date is passed through `new Date`. An unreadable value becomes an\n   * invalid Date, which `date()` rejects.\n   */\n  date: (): Coerced<WithBGuardType<CommonSchema, Date>, unknown> =>\n    date().transformBeforeValidation<unknown>((received) =>\n      received === null || received instanceof Date ? (received as Date) : new Date(received as string),\n    ) as unknown as Coerced<WithBGuardType<CommonSchema, Date>, unknown>,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AA2BO,IAAM,SAAS;AAAA;AAAA,EAEpB,QAAQ,MACN,OAAO,EAAE;AAAA,IAAmC,CAAC,aAC3C,aAAa,QAAQ,OAAO,aAAa,WAAY,WAAsB,OAAO,QAAQ;AAAA,EAC5F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOF,QAAQ,MACN,OAAO,EAAE;AAAA,IAAmC,CAAC,aAC3C,aAAa,QAAQ,OAAO,aAAa,WAAY,WAAsB,OAAO,QAAQ;AAAA,EAC5F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUF,SAAS,MACP,QAAQ,EAAE,0BAAmC,CAAC,aAAa;AACzD,QAAI,OAAO,aAAa,UAAU;AAChC,YAAM,UAAU,SAAS,YAAY;AACrC,UAAI,YAAY,OAAQ,QAAO;AAC/B,UAAI,YAAY,QAAS,QAAO;AAAA,IAClC;AAEA,QAAI,aAAa,EAAG,QAAO;AAC3B,QAAI,aAAa,EAAG,QAAO;AAE3B,WAAO;AAAA,EACT,CAAC;AAAA;AAAA,EAGH,QAAQ,MACN,OAAO,EAAE,0BAAmC,CAAC,aAAa;AACxD,QAAI,aAAa,QAAQ,OAAO,aAAa,SAAU,QAAO;AAE9D,QAAI;AACF,aAAO,OAAO,QAA2B;AAAA,IAC3C,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMH,MAAM,MACJ,KAAK,EAAE;AAAA,IAAmC,CAAC,aACzC,aAAa,QAAQ,oBAAoB,OAAQ,WAAoB,IAAI,KAAK,QAAkB;AAAA,EAClG;AACJ;","names":[]}

package/lib/chunk-KIVIWBIY.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
+
+// src/asserts/string/uuidV4.ts
+var uuidV4ErrorMessage = "The received value is not a valid UUID v4";
+var uuidV4ErrorKey = "s:uuidV4";
+var uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var uuidV4 = () => (received, ctx) => {
+  if (!uuidV4Pattern.test(received)) {
+    ctx.addIssue("uuid v4", received, uuidV4ErrorKey);
+  }
+};
+uuidV4.key = uuidV4ErrorKey;
+uuidV4.message = uuidV4ErrorMessage;
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, uuidV4);
+
+
+
+exports.uuidV4 = uuidV4;
+//# sourceMappingURL=chunk-KIVIWBIY.js.map

package/lib/chunk-KIVIWBIY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-KIVIWBIY.js","../src/asserts/string/uuidV4.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,mBAAA,EAAqB,2CAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAEvB,IAAM,cAAA,EAAgB,wEAAA;AAgBf,IAAM,OAAA,EAAS,CAAA,EAAA,GAAkC,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACnG,EAAA,GAAA,CAAI,CAAC,aAAA,CAAc,IAAA,CAAK,QAAQ,CAAA,EAAG;AACjC,IAAA,GAAA,CAAI,QAAA,CAAS,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAAA,EAClD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADdzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-KIVIWBIY.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV4ErrorMessage = 'The received value is not a valid UUID v4';\nconst uuidV4ErrorKey = 's:uuidV4';\n\nconst uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID v4 format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID v4.\n * @example\n * const schema = string().custom(uuidV4());\n * parseOrFail(schema, '123e4567-e89b-42d3-a456-426614174000'); // Valid\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-a2d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-42d3-c456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v4'\n *\n * @translation Error Translation Key = 's:uuidV4'\n */\nexport const uuidV4 = (): RequiredValidation<string> => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV4Pattern.test(received)) {\n    ctx.addIssue('uuid v4', received, uuidV4ErrorKey);\n  }\n};\n\nuuidV4.key = uuidV4ErrorKey;\nuuidV4.message = uuidV4ErrorMessage;\nsetToDefaultLocale(uuidV4);\n"]}

package/lib/chunk-KZBW5WCK.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
+
+// src/asserts/number/minExcluded.ts
+var minExcludedErrorMessage = "The received value is less than or equal to expected";
+var minExcludedErrorKey = "n:minExcluded";
+var minExcluded = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { exclusiveMinimum: expected }, (received, ctx) => {
+  if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);
+});
+minExcluded.key = minExcludedErrorKey;
+minExcluded.message = minExcludedErrorMessage;
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, minExcluded);
+
+
+
+exports.minExcluded = minExcluded;
+//# sourceMappingURL=chunk-KZBW5WCK.js.map

package/lib/chunk-KZBW5WCK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-KZBW5WCK.js","../src/asserts/number/minExcluded.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,wBAAA,EAA0B,sDAAA;AAChC,IAAM,oBAAA,EAAsB,eAAA;AAerB,IAAM,YAAA,EAAc,CAAC,QAAA,EAAA,GAC1B,yCAAA,EAAa,gBAAA,EAAkB,SAAS,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACtF,EAAA,GAAA,CAAI,SAAA,GAAY,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,mBAAmB,CAAA;AAChF,CAAC,CAAA;AAEH,WAAA,CAAY,IAAA,EAAM,mBAAA;AAClB,WAAA,CAAY,QAAA,EAAU,uBAAA;AACtB,iDAAA,WAA8B,CAAA;ADX9B;AACA;AACE;AACF,kCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-KZBW5WCK.js","sourcesContent":[null,"import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst minExcludedErrorMessage = 'The received value is less than or equal to expected';\nconst minExcludedErrorKey = 'n:minExcluded';\n\n/**\n * @description Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n * @param {number} expected The minimum allowable value, which is excluded.\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 or equal to the expected minimum value.\n * @example\n * const schema = number().custom(minExcluded(10));\n * parseOrFail(schema, 11);  // Valid\n * parseOrFail(schema, 10); // Throws an error: 'The received value is less than or equal to expected'\n * parseOrFail(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'\n *\n * @translation Error Translation Key = 'n:minExcluded'\n */\nexport const minExcluded = (expected: number): RequiredValidation<number> =>\n  _constrain({ exclusiveMinimum: expected }, (received: number, ctx: ExceptionContext) => {\n    if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);\n  });\n\nminExcluded.key = minExcludedErrorKey;\nminExcluded.message = minExcludedErrorMessage;\nsetToDefaultLocale(minExcluded);\n"]}

package/lib/chunk-L36PQXUB.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
+
+// src/asserts/number/min.ts
+var minErrorMessage = "The received value is less than expected";
+var minErrorKey = "n:min";
+var min = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { minimum: expected }, (received, ctx) => {
+  if (expected > received) ctx.addIssue(expected, received, minErrorKey);
+});
+min.key = minErrorKey;
+min.message = minErrorMessage;
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, min);
+
+
+
+exports.min = min;
+//# sourceMappingURL=chunk-L36PQXUB.js.map

package/lib/chunk-L36PQXUB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-L36PQXUB.js","../src/asserts/number/min.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,gBAAA,EAAkB,0CAAA;AACxB,IAAM,YAAA,EAAc,OAAA;AAeb,IAAM,IAAA,EAAM,CAAC,QAAA,EAAA,GAClB,yCAAA,EAAa,OAAA,EAAS,SAAS,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC7E,EAAA,GAAA,CAAI,SAAA,EAAW,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,WAAW,CAAA;AACvE,CAAC,CAAA;AAEH,GAAA,CAAI,IAAA,EAAM,WAAA;AACV,GAAA,CAAI,QAAA,EAAU,eAAA;AACd,iDAAA,GAAsB,CAAA;ADXtB;AACA;AACE;AACF,kBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-L36PQXUB.js","sourcesContent":[null,"import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { 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 = (expected: number): RequiredValidation<number> =>\n  _constrain({ minimum: expected }, (received: number, ctx: ExceptionContext) => {\n    if (expected > received) ctx.addIssue(expected, received, minErrorKey);\n  });\n\nmin.key = minErrorKey;\nmin.message = minErrorMessage;\nsetToDefaultLocale(min);\n"]}

package/lib/chunk-L7YFDMZU.js

@@ -0,0 +1,78 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunk3D6TPN7Fjs = require('./chunk-3D6TPN7F.js');
+
+
+var _chunkOPA6AXSHjs = require('./chunk-OPA6AXSH.js');
+
+
+var _chunkFTHEF6SBjs = require('./chunk-FTHEF6SB.js');
+
+
+var _chunk6LUSV3SSjs = require('./chunk-6LUSV3SS.js');
+
+
+var _chunkLHEU4XACjs = require('./chunk-LHEU4XAC.js');
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/asserts/bigint/index.ts
+function bigint() {
+  return new BigIntSchema({ type: ["bigint"], requiredValidations: [] });
+}
+var BigIntSchema = (_class = class extends _chunk6LUSV3SSjs.CommonSchema {constructor(...args) { super(...args); _class.prototype.__init.call(this); }
+  __init() {this._bigint = 1}
+  
+  /**
+   * @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 A new schema restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @example
+   * bigint().equalTo(42n); // Infers the type 42n
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    this.defaultValueCheck();
+    this.limitGuard();
+    const next = this.custom(_chunkOPA6AXSHjs.equalTo.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, next, `${expectedValue}n`);
+    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 A new schema 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();
+    this.limitGuard();
+    const next = this.custom(_chunk3D6TPN7Fjs.oneOfValues.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, 
+      next,
+      expectedValue.map((el) => `${el}n`)
+    );
+    return next;
+  }
+  /**
+   * 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 (0, _chunkZWFSAKQKjs.BuildSchemaError)(_chunkLHEU4XACjs.ONLY_ONCE);
+  }
+}, _class);
+
+
+
+exports.bigint = bigint;
+//# sourceMappingURL=chunk-L7YFDMZU.js.map

package/lib/chunk-L7YFDMZU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-L7YFDMZU.js","../src/asserts/bigint/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACAO,SAAS,MAAA,CAAA,EAA+C;AAC7D,EAAA,OAAO,IAAI,YAAA,CAAa,EAAE,IAAA,EAAM,CAAC,QAAQ,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAC,CAAA;AACvE;AAEA,IAAM,aAAA,YAAN,MAAA,QAA2B,8BAAa;AAAA,iBAC5B,QAAA,EAAU,EAAA;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,OAAA,CAA0B,aAAA,EAA2C;AAC1E,IAAA,IAAA,CAAK,iBAAA,CAAkB,CAAA;AACvB,IAAA,IAAA,CAAK,UAAA,CAAW,CAAA;AAChB,IAAA,MAAM,KAAA,EAAO,IAAA,CAAK,MAAA,CAAO,sCAAA,aAAqB,CAAC,CAAA;AAC/C,IAAA,IAAA,CAAK,MAAA,EAAQ,IAAA;AACb,IAAA,6CAAA,IAAe,EAAM,CAAA,EAAA;AACd,IAAA;AACT,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYqC,EAAA;AAC9B,IAAA;AACW,IAAA;AACE,IAAA;AACL,IAAA;AACb,IAAA;AACE,MAAA;AACmB,MAAA;AACrB,IAAA;AACO,IAAA;AACT,EAAA;AAAA;AAAA;AAAA;AAAA;AAMqB,EAAA;AACG,IAAA;AACxB,EAAA;AACF;ADF0B;AACA;AACA;AACA","file":"/home/runner/work/bguard/bguard/lib/chunk-L7YFDMZU.js","sourcesContent":[null,"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 A new schema 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.limitGuard();\n    const next = this.custom(equalTo(expectedValue));\n    next.limit = true;\n    _setStrictType(next, `${expectedValue}n`);\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   * 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.limitGuard();\n    const next = this.custom(oneOfValues(expectedValue));\n    next.limit = true;\n    _setStrictType(\n      next,\n      expectedValue.map((el) => `${el}n`),\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"]}