bguard 0.4.1 → 0.6.0

package/lib/chunk-NFD7D5GZ.mjs

@@ -0,0 +1,71 @@
+import {
+  oneOfValues
+} from "./chunk-W3U7RYLP.mjs";
+import {
+  equalTo
+} from "./chunk-4ZKU4RJL.mjs";
+import {
+  _setStrictType
+} from "./chunk-THU5VBSO.mjs";
+import {
+  CommonSchema
+} from "./chunk-QIPGUTIG.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-ZTCXXAKD.mjs";
+import {
+  ONLY_ONCE
+} from "./chunk-2ANPCB4O.mjs";
+
+// src/asserts/bigint/index.ts
+function bigint() {
+  return new BigIntSchema({ type: ["bigint"], requiredValidations: [] });
+}
+var BigIntSchema = class extends CommonSchema {
+  _bigint = 1;
+  limit;
+  /**
+   * @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
+   * @example
+   * bigint().equalTo(42n); // Infers the type 42n
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    this.defaultValueCheck();
+    this.limitCheck();
+    _setStrictType(this, `${expectedValue}n`);
+    return this.custom(equalTo(expectedValue));
+  }
+  /**
+   * @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.
+   * @example
+   * bigint().oneOfValues([5n, 7n]); // Infers the type 5n | 7n
+   *
+   * @public
+   */
+  oneOfValues(expectedValue) {
+    this.defaultValueCheck();
+    this.limitCheck();
+    _setStrictType(
+      this,
+      expectedValue.map((el) => `${el}n`)
+    );
+    return this.custom(oneOfValues(expectedValue));
+  }
+  limitCheck() {
+    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
+    this.limit = true;
+  }
+};
+
+export {
+  bigint
+};
+//# 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-H32B3NHW.mjs → chunk-OE3L7EKN.mjs}

@@ -1,6 +1,6 @@
 import {
   BuildSchemaError
-} from "./chunk-FGZKNBDP.mjs";
+} from "./chunk-ZTCXXAKD.mjs";
 
 // src/translationMap.ts
 var defaultErrorMap = {
@@ -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-H32B3NHW.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":[]}

package/lib/chunk-OU5BTUDV.mjs

@@ -0,0 +1,23 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/atLeastOneSpecialChar.ts
+var atLeastOneSpecialCharErrorMessage = "The received value does not contain at least one special character";
+var atLeastOneSpecialCharErrorKey = "s:atLeastOneSpecialChar";
+var atLeastOneSpecialChar = (allowedSpecialChars) => {
+  const specialCharRegExp = new RegExp(
+    `[${(allowedSpecialChars ?? "*@$!#%&()^~{}").replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}]`
+  );
+  return (received, ctx) => {
+    if (!specialCharRegExp.test(received)) ctx.addIssue("special character", received, atLeastOneSpecialCharErrorKey);
+  };
+};
+atLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;
+atLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;
+setToDefaultLocale(atLeastOneSpecialChar);
+
+export {
+  atLeastOneSpecialChar
+};
+//# sourceMappingURL=chunk-OU5BTUDV.mjs.map

package/lib/chunk-OU5BTUDV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/atLeastOneSpecialChar.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneSpecialCharErrorMessage = 'The received value does not contain at least one special character';\nconst atLeastOneSpecialCharErrorKey = 's:atLeastOneSpecialChar';\n\n/**\n * @description Asserts that a string value contains at least one special character.\n * @param {string} [allowedSpecialChars=*] The string containing allowed special characters. Defaults to '*@$!#%&()^~{}'.\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 of the allowed special characters.\n * @example\n * const schema = string().custom(atLeastOneSpecialChar()); // Default special characters\n * parseOrFail(schema, 'abc!def'); // Valid\n * parseOrFail(schema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * const customSchema = string().custom(atLeastOneSpecialChar('@$')); // Custom special characters\n * parseOrFail(customSchema, 'abc@def'); // Valid\n * parseOrFail(customSchema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * @translation Error Translation Key = 's:atLeastOneSpecialChar'\n */\nexport const atLeastOneSpecialChar = (allowedSpecialChars?: string): RequiredValidation => {\n  const specialCharRegExp = new RegExp(\n    `[${(allowedSpecialChars ?? '*@$!#%&()^~{}').replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')}]`,\n  );\n  return (received: string, ctx: ExceptionContext) => {\n    if (!specialCharRegExp.test(received)) ctx.addIssue('special character', received, atLeastOneSpecialCharErrorKey);\n  };\n};\n\natLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;\natLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;\nsetToDefaultLocale(atLeastOneSpecialChar);\n"],"mappings":";;;;;AAGA,IAAM,oCAAoC;AAC1C,IAAM,gCAAgC;AAkB/B,IAAM,wBAAwB,CAAC,wBAAqD;AACzF,QAAM,oBAAoB,IAAI;AAAA,IAC5B,KAAK,uBAAuB,iBAAiB,QAAQ,yBAAyB,MAAM,CAAC;AAAA,EACvF;AACA,SAAO,CAAC,UAAkB,QAA0B;AAClD,QAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAG,KAAI,SAAS,qBAAqB,UAAU,6BAA6B;AAAA,EAClH;AACF;AAEA,sBAAsB,MAAM;AAC5B,sBAAsB,UAAU;AAChC,mBAAmB,qBAAqB;","names":[]}

package/lib/chunk-OZ3BTSSQ.mjs

@@ -0,0 +1,64 @@
+import {
+  oneOfValues
+} from "./chunk-W3U7RYLP.mjs";
+import {
+  equalTo
+} from "./chunk-4ZKU4RJL.mjs";
+import {
+  _setStrictType
+} from "./chunk-THU5VBSO.mjs";
+import {
+  CommonSchema
+} from "./chunk-QIPGUTIG.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-ZTCXXAKD.mjs";
+import {
+  ONLY_ONCE
+} from "./chunk-2ANPCB4O.mjs";
+
+// src/asserts/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+var NumberSchema = class extends CommonSchema {
+  _number = 1;
+  limit;
+  /**
+   * @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
+   * @example
+   * number().equalTo(42); // Infers the type 42
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
+    this.limit = true;
+    _setStrictType(this, expectedValue);
+    return this.custom(equalTo(expectedValue));
+  }
+  /**
+   * @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.
+   * @example
+   * number().oneOfValues([5, 7]); // Infers the type 5 | 7
+   *
+   * @public
+   */
+  oneOfValues(expectedValue) {
+    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
+    this.limit = true;
+    _setStrictType(this, expectedValue);
+    return this.custom(oneOfValues(expectedValue));
+  }
+};
+
+export {
+  number
+};
+//# sourceMappingURL=chunk-OZ3BTSSQ.mjs.map

package/lib/chunk-OZ3BTSSQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/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 number values.\n * @returns {NumberSchema} A new instance of `NumberSchema` for validating numbers.\n * @example\n * const schema = number();\n * parseOrFail(schema, 42); // Validates successfully\n * parseOrFail(schema, '42'); // Throws a validation error\n *\n * @instance Of NumberSchema\n */\nexport function number(): WithBGuardType<NumberSchema, number> {\n  return new NumberSchema({ type: ['number'], requiredValidations: [] }) as WithBGuardType<NumberSchema, number>;\n}\n\nclass NumberSchema extends CommonSchema {\n  protected _number = 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   * number().equalTo(42); // Infers the type 42\n   *\n   * @public\n   */\n  public equalTo<Y extends number>(expectedValue: Y): WithBGuardType<this, Y> {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n    this.limit = true;\n    _setStrictType(this, expectedValue);\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   * number().oneOfValues([5, 7]); // Infers the type 5 | 7\n   *\n   * @public\n   */\n  public oneOfValues<Y extends number>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n    this.limit = true;\n    _setStrictType(this, expectedValue);\n    return this.custom(oneOfValues(expectedValue)) as WithBGuardType<this, Y>;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBO,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,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AACpD,SAAK,QAAQ;AACb,mBAAe,MAAM,aAAa;AAClC,WAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAA8B,eAA6C;AAChF,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AACpD,SAAK,QAAQ;AACb,mBAAe,MAAM,aAAa;AAClC,WAAO,KAAK,OAAO,YAAY,aAAa,CAAC;AAAA,EAC/C;AACF;","names":[]}

package/lib/{chunk-IZ3CBVEE.js → chunk-PAV4SQQL.js}

@@ -1,21 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk5YYRBKDPjs = require('./chunk-5YYRBKDP.js');
-
-
-var _chunk5P6AZJCNjs = require('./chunk-5P6AZJCN.js');
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
 
 // src/asserts/mix/oneOfValues.ts
 var oneOfValuesErrorMessage = "The received value is not equal to expected";
 var oneOfValuesErrorKey = "m:oneOfValues";
 var oneOfValues = (expected) => (received, ctx) => {
-  if (!expected.includes(received)) _chunk5P6AZJCNjs.guardException.call(void 0, expected, received, ctx, oneOfValuesErrorKey);
+  if (!expected.includes(received)) ctx.addIssue(expected, received, oneOfValuesErrorKey);
 };
 oneOfValues.key = oneOfValuesErrorKey;
 oneOfValues.message = oneOfValuesErrorMessage;
-_chunk5YYRBKDPjs.setToDefaultLocale.call(void 0, oneOfValues);
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, oneOfValues);
 
 
 
 exports.oneOfValues = oneOfValues;
-//# sourceMappingURL=chunk-IZ3CBVEE.js.map
+//# sourceMappingURL=chunk-PAV4SQQL.js.map

package/lib/chunk-PAV4SQQL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-PAV4SQQL.js","../src/asserts/mix/oneOfValues.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,wBAAA,EAA0B,6CAAA;AAChC,IAAM,oBAAA,EAAsB,eAAA;AAgBrB,IAAM,YAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAmB,GAAA,EAAA,GAA0B;AAC5C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,QAAA,CAAS,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,mBAAmB,CAAA;AACxF,CAAA;AAEF,WAAA,CAAY,IAAA,EAAM,mBAAA;AAClB,WAAA,CAAY,QAAA,EAAU,uBAAA;AACtB,iDAAA,WAA8B,CAAA;ADf9B;AACA;AACE;AACF,kCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-PAV4SQQL.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst oneOfValuesErrorMessage = 'The received value is not equal to expected';\nconst oneOfValuesErrorKey = 'm:oneOfValues';\n\n/**\n * @description Creates a custom assertion that checks if a value is equal to the one of expected values.\n * @notice It has already been implemented in the number, bigint and string schema. There is no need to use it as a custom assert.\n * @param {unknown} expected The value that the received value is expected to match.\n * @returns {RequiredValidation} A validation function that takes a received value and an exception context.\n * @throws {ValidationError} If the received value does not match at least one of the expected values.\n * @example\n * const schema = number().custom(oneOfValues([5, 4])); // Define a schema with a custom assertion\n * parseOrFail(schema, 5); // Valid\n * parseOrFail(schema, 4); // Valid\n * parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'\n *\n * @translation Error Translation Key = 'm:oneOfValues'\n */\nexport const oneOfValues =\n  (expected: unknown[]): RequiredValidation =>\n  (received: unknown, ctx: ExceptionContext) => {\n    if (!expected.includes(received)) ctx.addIssue(expected, received, oneOfValuesErrorKey);\n  };\n\noneOfValues.key = oneOfValuesErrorKey;\noneOfValues.message = oneOfValuesErrorMessage;\nsetToDefaultLocale(oneOfValues);\n"]}

package/lib/chunk-PNSDUVRE.mjs

@@ -0,0 +1,21 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// 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;
+setToDefaultLocale(uuidV4);
+
+export {
+  uuidV4
+};
+//# sourceMappingURL=chunk-PNSDUVRE.mjs.map

package/lib/chunk-PNSDUVRE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/uuidV4.ts"],"sourcesContent":["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 => (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"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAgBf,IAAM,SAAS,MAA0B,CAAC,UAAkB,QAA0B;AAC3F,MAAI,CAAC,cAAc,KAAK,QAAQ,GAAG;AACjC,QAAI,SAAS,WAAW,UAAU,cAAc;AAAA,EAClD;AACF;AAEA,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}

package/lib/chunk-PVQALO2H.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/string/atLeastOneSpecialChar.ts
+var atLeastOneSpecialCharErrorMessage = "The received value does not contain at least one special character";
+var atLeastOneSpecialCharErrorKey = "s:atLeastOneSpecialChar";
+var atLeastOneSpecialChar = (allowedSpecialChars) => {
+  const specialCharRegExp = new RegExp(
+    `[${(_nullishCoalesce(allowedSpecialChars, () => ( "*@$!#%&()^~{}"))).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}]`
+  );
+  return (received, ctx) => {
+    if (!specialCharRegExp.test(received)) ctx.addIssue("special character", received, atLeastOneSpecialCharErrorKey);
+  };
+};
+atLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;
+atLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, atLeastOneSpecialChar);
+
+
+
+exports.atLeastOneSpecialChar = atLeastOneSpecialChar;
+//# sourceMappingURL=chunk-PVQALO2H.js.map

package/lib/chunk-PVQALO2H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-PVQALO2H.js","../src/asserts/string/atLeastOneSpecialChar.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,kCAAA,EAAoC,oEAAA;AAC1C,IAAM,8BAAA,EAAgC,yBAAA;AAkB/B,IAAM,sBAAA,EAAwB,CAAC,mBAAA,EAAA,GAAqD;AACzF,EAAA,MAAM,kBAAA,EAAoB,IAAI,MAAA;AAAA,IAC5B,CAAA,CAAA,EAAA,kBAAK,mBAAA,UAAuB,iBAAA,CAAA,CAAiB,OAAA,CAAQ,uBAAA,EAAyB,MAAM,CAAC,CAAA,CAAA;AAAA,EACvF,CAAA;AACA,EAAA,OAAO,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAClD,IAAA,GAAA,CAAI,CAAC,iBAAA,CAAkB,IAAA,CAAK,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,mBAAA,EAAqB,QAAA,EAAU,6BAA6B,CAAA;AAAA,EAClH,CAAA;AACF,CAAA;AAEA,qBAAA,CAAsB,IAAA,EAAM,6BAAA;AAC5B,qBAAA,CAAsB,QAAA,EAAU,iCAAA;AAChC,iDAAA,qBAAwC,CAAA;ADfxC;AACA;AACE;AACF,sDAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-PVQALO2H.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneSpecialCharErrorMessage = 'The received value does not contain at least one special character';\nconst atLeastOneSpecialCharErrorKey = 's:atLeastOneSpecialChar';\n\n/**\n * @description Asserts that a string value contains at least one special character.\n * @param {string} [allowedSpecialChars=*] The string containing allowed special characters. Defaults to '*@$!#%&()^~{}'.\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 of the allowed special characters.\n * @example\n * const schema = string().custom(atLeastOneSpecialChar()); // Default special characters\n * parseOrFail(schema, 'abc!def'); // Valid\n * parseOrFail(schema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * const customSchema = string().custom(atLeastOneSpecialChar('@$')); // Custom special characters\n * parseOrFail(customSchema, 'abc@def'); // Valid\n * parseOrFail(customSchema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * @translation Error Translation Key = 's:atLeastOneSpecialChar'\n */\nexport const atLeastOneSpecialChar = (allowedSpecialChars?: string): RequiredValidation => {\n  const specialCharRegExp = new RegExp(\n    `[${(allowedSpecialChars ?? '*@$!#%&()^~{}').replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')}]`,\n  );\n  return (received: string, ctx: ExceptionContext) => {\n    if (!specialCharRegExp.test(received)) ctx.addIssue('special character', received, atLeastOneSpecialCharErrorKey);\n  };\n};\n\natLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;\natLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;\nsetToDefaultLocale(atLeastOneSpecialChar);\n"]}

package/lib/chunk-QEG24G7E.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// 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;
+setToDefaultLocale(bigintMax);
+
+export {
+  bigintMax
+};
+//# sourceMappingURL=chunk-QEG24G7E.mjs.map

package/lib/chunk-QEG24G7E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/bigint/bigintMax.ts"],"sourcesContent":["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"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAenB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,WAAW,SAAU,KAAI,SAAS,UAAU,UAAU,iBAAiB;AAC7E;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/chunk-QIFA6S5U.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/bigint/bigintMaxExcluded.ts
+var bigintMaxExcludedErrorMessage = "The received value is greater than or equal to expected";
+var bigintMaxExcludedErrorKey = "bi:maxExcluded";
+var bigintMaxExcluded = (expected) => (received, ctx) => {
+  if (expected <= received) ctx.addIssue(expected, received, bigintMaxExcludedErrorKey);
+};
+bigintMaxExcluded.key = bigintMaxExcludedErrorKey;
+bigintMaxExcluded.message = bigintMaxExcludedErrorMessage;
+setToDefaultLocale(bigintMaxExcluded);
+
+export {
+  bigintMaxExcluded
+};
+//# sourceMappingURL=chunk-QIFA6S5U.mjs.map