bguard 0.6.0 → 0.7.1

package/lib/{chunk-OE3L7EKN.mjs → chunk-65X7NTUS.mjs}

@@ -1,6 +1,6 @@
 import {
   BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-O2WD4JBG.mjs";
 
 // src/translationMap.ts
 var defaultErrorMap = {
@@ -14,23 +14,32 @@ var defaultErrorMap = {
   "c:requiredProperty": "Missing required property in the object",
   "c:invalidType": "Invalid type of data",
   "c:isBoolean": "The received value is not {{e}}",
-  "c:date": "The received value is not a valid instance of Date"
+  "c:date": "The received value is not a valid instance of Date",
+  "c:nan": "The received number is not a valid number",
+  "c:union": "The received value does not match any of the expected types",
+  "c:tupleLength": "The received tuple has {{r}} entries but {{e}} were expected"
   //@@end
 };
+var registeredDefaults = {};
+function baseMessages() {
+  return { ...defaultErrorMap, ...registeredDefaults };
+}
 var data = {
-  default: { ...defaultErrorMap }
+  default: baseMessages()
 };
 function setToDefaultLocale({
   key,
   message
 }) {
-  const defaultLocale = data.default;
-  if (defaultLocale[key]) throw new BuildSchemaError("Duplicate default message key");
-  defaultLocale[key] = message;
+  if (registeredDefaults[key] ?? defaultErrorMap[key]) throw new BuildSchemaError("Duplicate default message key");
+  registeredDefaults[key] = message;
+  Object.values(data).forEach((locale) => {
+    locale[key] ??= message;
+  });
 }
 function setLocale(lng, custom) {
   if (lng === "default") throw new BuildSchemaError("Invalid language");
-  data[lng] ??= { ...defaultErrorMap };
+  data[lng] ??= baseMessages();
   const locale = data[lng];
   Object.entries(custom).forEach(([messageKey, messageValue]) => {
     locale[messageKey] = messageValue;
@@ -38,7 +47,7 @@ function setLocale(lng, custom) {
 }
 function clearLocales() {
   data = {
-    default: { ...defaultErrorMap }
+    default: baseMessages()
   };
 }
 function getTranslationByLocale(lng) {
@@ -52,4 +61,4 @@ export {
   clearLocales,
   getTranslationByLocale
 };
-//# sourceMappingURL=chunk-OE3L7EKN.mjs.map
+//# sourceMappingURL=chunk-65X7NTUS.mjs.map

package/lib/chunk-65X7NTUS.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  'c:nan': 'The received number is not a valid number',\n  'c:union': 'The received value does not match any of the expected types',\n  'c:tupleLength': 'The received tuple has {{r}} entries but {{e}} were expected',\n  //@@end\n};\n\n/**\n * Messages registered by asserts through `setToDefaultLocale`, kept apart from the locale data.\n *\n * Every assert registers its default message once, when its module is first imported. Those\n * registrations can never happen again, so they have to survive `clearLocales`, and they have to\n * seed every locale created by `setLocale` — otherwise a locale that translates one key reports\n * every other key as its raw name.\n */\nconst registeredDefaults: Record<string, string> = {};\n\n/** The messages a fresh locale starts from: the common ones plus everything asserts registered. */\nfunction baseMessages(): Record<string, string> {\n  return { ...defaultErrorMap, ...registeredDefaults };\n}\n\nlet data: Record<string, Record<string, string>> = {\n  default: baseMessages(),\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  if (registeredDefaults[key] ?? defaultErrorMap[key]) throw new BuildSchemaError('Duplicate default message key');\n  registeredDefaults[key] = message;\n\n  // Keep locales that already exist in step, so registration order does not matter.\n  Object.values(data).forEach((locale) => {\n    locale[key] ??= message;\n  });\n}\n\nexport function setLocale(lng: string, custom: Partial<TranslationErrorMap>) {\n  if (lng === 'default') throw new BuildSchemaError('Invalid language');\n  data[lng] ??= baseMessages();\n  const locale = data[lng];\n  Object.entries(custom).forEach(([messageKey, messageValue]) => {\n    locale[messageKey] = messageValue!;\n  });\n}\n\n/**\n * Drops every locale and returns the default one to its registered messages.\n *\n * Assert registrations are deliberately kept: they describe the schemas, not a translation, and\n * clearing them would leave every built-in assert reporting its key instead of a message.\n */\nexport function clearLocales() {\n  data = {\n    default: baseMessages(),\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,EACV,SAAS;AAAA,EACT,WAAW;AAAA,EACX,iBAAiB;AAAA;AAEnB;AAUA,IAAM,qBAA6C,CAAC;AAGpD,SAAS,eAAuC;AAC9C,SAAO,EAAE,GAAG,iBAAiB,GAAG,mBAAmB;AACrD;AAEA,IAAI,OAA+C;AAAA,EACjD,SAAS,aAAa;AACxB;AAEO,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AACF,GAKG;AACD,MAAI,mBAAmB,GAAG,KAAK,gBAAgB,GAAG,EAAG,OAAM,IAAI,iBAAiB,+BAA+B;AAC/G,qBAAmB,GAAG,IAAI;AAG1B,SAAO,OAAO,IAAI,EAAE,QAAQ,CAAC,WAAW;AACtC,WAAO,GAAG,MAAM;AAAA,EAClB,CAAC;AACH;AAEO,SAAS,UAAU,KAAa,QAAsC;AAC3E,MAAI,QAAQ,UAAW,OAAM,IAAI,iBAAiB,kBAAkB;AACpE,OAAK,GAAG,MAAM,aAAa;AAC3B,QAAM,SAAS,KAAK,GAAG;AACvB,SAAO,QAAQ,MAAM,EAAE,QAAQ,CAAC,CAAC,YAAY,YAAY,MAAM;AAC7D,WAAO,UAAU,IAAI;AAAA,EACvB,CAAC;AACH;AAQO,SAAS,eAAe;AAC7B,SAAO;AAAA,IACL,SAAS,aAAa;AAAA,EACxB;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-6LUSV3SS.js

@@ -0,0 +1,595 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
+
+
+var _chunkVBTWYDEMjs = require('./chunk-VBTWYDEM.js');
+
+
+var _chunkLHEU4XACjs = require('./chunk-LHEU4XAC.js');
+
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/core.ts
+var replacePlaceholdersRegex = /{{(.*?)}}/g;
+function replacePlaceholders(template, replacements) {
+  return template.replace(replacePlaceholdersRegex, (_, key) => {
+    return key in replacements ? `${replacements[key]}` : `{{${key}}}`;
+  });
+}
+var ExceptionContext = class _ExceptionContext {
+  constructor(initialReceived, t, pathToError, errors, meta, path = [], pending) {
+    this.initialReceived = initialReceived;
+    this.t = t;
+    this.pathToError = pathToError;
+    this.errors = errors;
+    this.meta = meta;
+    this.path = path;
+    this.pending = pending;
+  }
+  
+  
+  
+  
+  
+  
+  
+  /**
+   * The same location, reporting into a different errors list.
+   *
+   * A union tries each member against a throwaway list so a member that does not match is not fatal.
+   * An async validation reached inside the winning member is awaited long after that decision, so it
+   * has to be re-pointed at the real list or its issues would be collected where nobody reads them.
+   */
+  withErrors(errors) {
+    return new _ExceptionContext(
+      this.initialReceived,
+      this.t,
+      this.pathToError,
+      errors,
+      this.meta,
+      this.path,
+      this.pending
+    );
+  }
+  /**
+   * Records async validations to be awaited once the walk is over.
+   *
+   * Throws during a synchronous parse rather than dropping them: a validation that never runs is worse
+   * than a clear instruction to use parseAsync.
+   */
+  enqueueAsync(validations, received) {
+    if (!this.pending) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Schema has an async validation. Use parseAsync or parseOrFailAsync");
+    this.pending.push({ validations, received, ctx: this });
+  }
+  /**
+   * Descends into a property or an index, deriving both forms of the location from the same key so
+   * they cannot disagree.
+   */
+  createChild(pathSegment, childMeta) {
+    const childPathToError = typeof pathSegment === "number" ? `${this.pathToError}[${pathSegment}]` : `${this.pathToError}.${String(pathSegment)}`;
+    return new _ExceptionContext(
+      this.initialReceived,
+      this.t,
+      childPathToError,
+      this.errors,
+      childMeta,
+      [...this.path, pathSegment],
+      this.pending
+    );
+  }
+  ref(path) {
+    let ref = this.initialReceived;
+    for (const el of path.split(".")) {
+      if (ref === null || ref === void 0) return void 0;
+      ref = ref[el];
+    }
+    return ref;
+  }
+  addIssue(expected, received, messageKey) {
+    const rawMessage = _nullishCoalesce(this.t[messageKey], () => ( messageKey));
+    const message = replacePlaceholders(rawMessage, { e: expected, r: received, p: this.pathToError });
+    if (this.errors) {
+      this.errors.push({
+        expected,
+        received,
+        pathToError: this.pathToError,
+        path: this.path,
+        code: messageKey,
+        message,
+        meta: this.meta
+      });
+      return;
+    }
+    throw new (0, _chunkZWFSAKQKjs.ValidationError)(expected, received, this.pathToError, message, this.meta, this.path, messageKey);
+  }
+};
+function runValidations(schemaData, receivedValue, exCtx) {
+  schemaData.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, exCtx);
+  });
+  if (_optionalChain([schemaData, 'access', _2 => _2.asyncValidations, 'optionalAccess', _3 => _3.length])) exCtx.enqueueAsync(schemaData.asyncValidations, receivedValue);
+}
+function innerCheck(schema, receivedValue, exCtx) {
+  const schemaData = schema[_chunkLHEU4XACjs.ctxSymbol];
+  if (receivedValue !== void 0) {
+    _optionalChain([schemaData, 'access', _4 => _4.transformListBefore, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((transformCallback) => {
+      receivedValue = transformCallback(receivedValue);
+    })]);
+  }
+  if (receivedValue === void 0) {
+    if (schemaData.defaultValue === void 0) {
+      if (!schemaData.isOptional) exCtx.addIssue("Required", receivedValue, "c:optional");
+      return receivedValue;
+    }
+    receivedValue = schemaData.defaultValue;
+  }
+  if (receivedValue === null) {
+    if (!schemaData.isNullable) exCtx.addIssue("Not null", receivedValue, "c:nullable");
+    return receivedValue;
+  }
+  if (schemaData.date) {
+    if (!_chunkVBTWYDEMjs.isValidDateInner.call(void 0, receivedValue)) exCtx.addIssue("Date", receivedValue, "c:date");
+  }
+  const typeOfVal = typeof receivedValue;
+  if (schemaData.type.length) {
+    if (!schemaData.type.includes(typeOfVal)) exCtx.addIssue(schemaData.type, typeOfVal, "c:invalidType");
+    else if (typeOfVal === "number" && Number.isNaN(receivedValue)) exCtx.addIssue("number", receivedValue, "c:nan");
+  }
+  if (schemaData.lazy) {
+    schemaData.lazy.resolved ??= schemaData.lazy.getSchema();
+    if (!(schemaData.lazy.resolved instanceof CommonSchema))
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Invalid schema returned from lazy method");
+    return innerCheck(schemaData.lazy.resolved, receivedValue, exCtx);
+  }
+  if (schemaData.tuple) {
+    if (!Array.isArray(receivedValue)) return exCtx.addIssue("Array", receivedValue, "c:array");
+    runValidations(schemaData, receivedValue, exCtx);
+    if (receivedValue.length !== schemaData.tuple.length) {
+      exCtx.addIssue(schemaData.tuple.length, receivedValue.length, "c:tupleLength");
+      return receivedValue;
+    }
+    const parsedTuple = [];
+    for (let i = 0; i < schemaData.tuple.length; i++) {
+      const positionSchema = schemaData.tuple[i];
+      parsedTuple.push(
+        innerCheck(
+          positionSchema,
+          receivedValue[i],
+          exCtx.createChild(i, _nullishCoalesce(positionSchema[_chunkLHEU4XACjs.ctxSymbol].meta, () => ( schemaData.meta)))
+        )
+      );
+    }
+    return parsedTuple;
+  }
+  if (schemaData.union) {
+    runValidations(schemaData, receivedValue, exCtx);
+    const attemptErrors = [];
+    for (const memberSchema of schemaData.union) {
+      const errorsBefore = attemptErrors.length;
+      const attemptPending = [];
+      const attemptCtx = new ExceptionContext(
+        exCtx.initialReceived,
+        exCtx.t,
+        exCtx.pathToError,
+        attemptErrors,
+        schemaData.meta,
+        // Carried over, so an async validation inside the winning member keeps the right location.
+        exCtx.path,
+        exCtx.pending && attemptPending
+      );
+      const parsedMember = innerCheck(memberSchema, receivedValue, attemptCtx);
+      if (attemptErrors.length === errorsBefore) {
+        for (const entry of attemptPending) {
+          _optionalChain([exCtx, 'access', _7 => _7.pending, 'optionalAccess', _8 => _8.push, 'call', _9 => _9({ ...entry, ctx: entry.ctx.withErrors(exCtx.errors) })]);
+        }
+        return parsedMember;
+      }
+    }
+    exCtx.addIssue("One of the union members", receivedValue, "c:union");
+    return receivedValue;
+  }
+  if (schemaData.record) {
+    if (typeOfVal !== "object" || Array.isArray(receivedValue)) {
+      if (Array.isArray(receivedValue)) {
+        exCtx.addIssue("Object", receivedValue, "c:objectTypeAsArray");
+      } else {
+        exCtx.addIssue("Object", receivedValue, "c:objectType");
+      }
+      return receivedValue;
+    }
+    runValidations(schemaData, receivedValue, exCtx);
+    const { key: keySchema, value: valueSchema } = schemaData.record;
+    const parsedRecord = {};
+    for (const [receivedKey, receivedRecordValue] of Object.entries(receivedValue)) {
+      const childCtx = exCtx.createChild(receivedKey, schemaData.meta);
+      innerCheck(keySchema, receivedKey, childCtx);
+      parsedRecord[receivedKey] = innerCheck(valueSchema, receivedRecordValue, childCtx);
+    }
+    return parsedRecord;
+  }
+  if (schemaData.array) {
+    if (!Array.isArray(receivedValue)) return exCtx.addIssue("Array", receivedValue, "c:array");
+    runValidations(schemaData, receivedValue, exCtx);
+    const schema2 = schemaData.array;
+    const parsedReceivedValue = [];
+    for (let i = 0; i < receivedValue.length; i++) {
+      const parsedElement = innerCheck(
+        schema2,
+        receivedValue[i],
+        // The element's own metadata wins; the array's is inherited when it has none.
+        exCtx.createChild(i, _nullishCoalesce(schema2[_chunkLHEU4XACjs.ctxSymbol].meta, () => ( schemaData.meta)))
+      );
+      parsedReceivedValue.push(parsedElement);
+    }
+    return parsedReceivedValue;
+  }
+  if (schemaData.object) {
+    if (typeOfVal !== "object" || Array.isArray(receivedValue)) {
+      if (Array.isArray(receivedValue)) {
+        exCtx.addIssue("Object", receivedValue, "c:objectTypeAsArray");
+      } else {
+        exCtx.addIssue("Object", receivedValue, "c:objectType");
+      }
+      return receivedValue;
+    }
+    runValidations(schemaData, receivedValue, exCtx);
+    const shapeSchema = schemaData.object;
+    const parsedReceivedValue = {};
+    const receivedObject = receivedValue;
+    if (!schemaData.allowUnrecognizedObjectProps) {
+      for (const keyPerReceivedValue of Object.keys(receivedObject)) {
+        if (!Object.prototype.hasOwnProperty.call(shapeSchema, keyPerReceivedValue))
+          exCtx.addIssue("Unrecognized property", keyPerReceivedValue, "c:unrecognizedProperty");
+      }
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const valueSchemaData = valueOfSchema[_chunkLHEU4XACjs.ctxSymbol];
+      const receivedObjectValuePropery = receivedObject[keyOfSchema];
+      if (receivedObjectValuePropery === void 0 && !valueSchemaData.isOptional && // A property with a default is not missing: innerCheck substitutes the value below. The
+      // check used to run first and reject it, so default() could never apply to a property.
+      valueSchemaData.defaultValue === void 0) {
+        exCtx.createChild(keyOfSchema, _nullishCoalesce(valueSchemaData.meta, () => ( schemaData.meta))).addIssue("Required", receivedObjectValuePropery, "c:requiredProperty");
+        continue;
+      }
+      const parsedReceivedObjectValuePropery = innerCheck(
+        valueOfSchema,
+        receivedObjectValuePropery,
+        exCtx.createChild(keyOfSchema, _nullishCoalesce(valueSchemaData.meta, () => ( schemaData.meta)))
+      );
+      if (parsedReceivedObjectValuePropery !== void 0 || Object.prototype.hasOwnProperty.call(receivedObject, keyOfSchema)) {
+        parsedReceivedValue[keyOfSchema] = parsedReceivedObjectValuePropery;
+      }
+    }
+    return parsedReceivedValue;
+  }
+  runValidations(schemaData, receivedValue, exCtx);
+  return receivedValue;
+}
+function cloneValidatorContext(ctx) {
+  const next = {
+    ...ctx,
+    type: [...ctx.type],
+    requiredValidations: [...ctx.requiredValidations]
+  };
+  if (ctx.asyncValidations) next.asyncValidations = [...ctx.asyncValidations];
+  if (ctx.object) next.object = { ...ctx.object };
+  if (ctx.union) next.union = [...ctx.union];
+  if (ctx.record) next.record = { ...ctx.record };
+  if (ctx.tuple) next.tuple = [...ctx.tuple];
+  if (ctx.lazy) next.lazy = { ...ctx.lazy };
+  if (ctx.transformListBefore) next.transformListBefore = [...ctx.transformListBefore];
+  if (ctx.meta) next.meta = { ...ctx.meta };
+  return next;
+}
+var CommonSchema = class {
+  
+  constructor(ctx) {
+    this[_chunkLHEU4XACjs.ctxSymbol] = ctx;
+  }
+  /**
+   * The Standard Schema v1 interface, which lets a bguard schema be used by any library that accepts
+   * a validator without either side knowing about the other.
+   *
+   * A getter rather than a stored property, so it costs nothing until something asks for it and is
+   * not copied by `clone`. `types` is declared but deliberately never assigned: the spec defines it
+   * as type-only. Input and output are reported separately, so a consumer generating a form asks for
+   * what the schema takes rather than what it returns.
+   */
+  get "~standard"() {
+    return {
+      version: 1,
+      vendor: "bguard",
+      // An arrow function, so `this` is the schema however the property is destructured or passed on.
+      validate: (value) => {
+        if (hasAsyncValidation(this)) return parseAsync(this, value, { getAllErrors: true }).then(toStandardResult);
+        return toStandardResult(parse(this, value, { getAllErrors: true }));
+      }
+    };
+  }
+  /**
+   * Returns a copy of this schema that carries its own context.
+   *
+   * Every refining method goes through this, so a schema can be shared between properties and
+   * reused as a base without one use leaking into another. Construction is deliberately bypassed:
+   * the subclass constructors validate their arguments and take extra parameters, and neither
+   * applies when deriving from an already-valid schema.
+   *
+   * Public because deriving a schema is a reasonable thing to do from outside as well — the object
+   * utilities need it to rebuild a property schema without touching the one they were handed.
+   */
+  clone() {
+    const next = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    next[_chunkLHEU4XACjs.ctxSymbol] = cloneValidatorContext(this[_chunkLHEU4XACjs.ctxSymbol]);
+    return next;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} A new schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this.defaultValueCheck();
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].requiredValidations.push(...validators);
+    return next;
+  }
+  /**
+   * Adds validations that have to wait for something, such as a database lookup.
+   *
+   * These run only under `parseAsync` or `parseOrFailAsync`; a synchronous parse reports a
+   * `BuildSchemaError` rather than skipping them. They are awaited after the structural walk is
+   * complete, all together, so several slow checks across a schema cost one round of waiting.
+   *
+   * @param validators - One or more async validation functions.
+   * @returns {this} A new schema instance with the added validations.
+   * @example
+   * const schema = string().customAsync(async (received, ctx) => {
+   *   if (await isTaken(received)) ctx.addIssue('an unused name', received, 'name is taken');
+   * });
+   */
+  customAsync(...validators) {
+    this.defaultValueCheck();
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].asyncValidations = [..._nullishCoalesce(next[_chunkLHEU4XACjs.ctxSymbol].asyncValidations, () => ( [])), ...validators];
+    return next;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} A new schema instance marked as nullable.
+   */
+  nullable() {
+    this.defaultValueCheck();
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].isNullable = true;
+    return next;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>} A new schema instance marked as optional.
+   */
+  optional() {
+    this.defaultValueCheck();
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].isOptional = true;
+    return next;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {this} The schema instance. This method should be used as a last one because it does the check of previous methods and
+   */
+  default(defaultValue) {
+    const ctx = this[_chunkLHEU4XACjs.ctxSymbol];
+    if (ctx.isOptional) {
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Cannot call method 'default' after method 'optional'`);
+    }
+    try {
+      parseOrFail(this, defaultValue);
+    } catch (e) {
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(e.message);
+    }
+    const next = this.clone();
+    next[_chunkLHEU4XACjs.ctxSymbol].defaultValue = defaultValue;
+    return next;
+  }
+  /**
+   * Applies a transformation to the input value before any validation occurs.
+   * The transformation should return a value of the same type as the inferred type of the schema,
+   * ensuring that the overall type is not altered.
+   *
+   * @template In - The type of the input value before transformation (defaults to `unknown`).
+   * @param {TransformCallback<In, InferType<this>>} cb - The callback function that performs the transformation.
+   * @returns {this} A new schema with the applied transformation.
+   *
+   * @example
+   * const schema = string()
+   *   .nullable()
+   *   .transformBeforeValidation((val) => val + '') // Ensure the value is a string
+   *   .transformBeforeValidation((val: string) => (val === '' ? null : val)); // Convert empty strings to null
+   *
+   * // Parse 'test' will pass as 'test' is a valid string longer than 3 characters.
+   * parseOrFail(schema, 'test');
+   *
+   * // Parsing '' will be transformed to null and will pass due to .nullable().
+   * parseOrFail(schema, '');
+   */
+  transformBeforeValidation(cb) {
+    const next = this.clone();
+    const ctx = next[_chunkLHEU4XACjs.ctxSymbol];
+    if (ctx.transformListBefore) {
+      ctx.transformListBefore.push(cb);
+    } else {
+      ctx.transformListBefore = [cb];
+    }
+    return next;
+  }
+  /**
+   * Assigns a unique identifier to the schema.
+   * This ID can be used to track or map validation errors back to specific fields
+   * in a form or other structures.
+   *
+   * @param {string} value - The unique identifier for the schema.
+   * @returns {this} A new schema with the assigned ID.
+   *
+   * @example
+   * const schema = string().id('username');
+   */
+  id(value) {
+    return this.meta("id", value);
+  }
+  /**
+   * Provides a description for the schema, offering additional context or information.
+   * The description can be used when displaying validation errors or for documentation purposes.
+   *
+   * @param {string} value - The description for the schema.
+   * @returns {this} A new schema with the added description.
+   *
+   * @example
+   * const schema = string().description('The username of the account holder.');
+   */
+  description(value) {
+    return this.meta("description", value);
+  }
+  meta(key, value) {
+    const next = this.clone();
+    const ctx = next[_chunkLHEU4XACjs.ctxSymbol];
+    ctx.meta = { ...ctx.meta, [key]: value };
+    return next;
+  }
+  defaultValueCheck() {
+    if (this[_chunkLHEU4XACjs.ctxSymbol].defaultValue !== void 0) {
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Default value must be the last method called in schema");
+    }
+  }
+};
+function parseOrFail(schema, receivedValue, options) {
+  try {
+    const ctx = new ExceptionContext(
+      receivedValue,
+      _chunkZJGY6EOEjs.getTranslationByLocale.call(void 0, _optionalChain([options, 'optionalAccess', _10 => _10.lng])),
+      "",
+      void 0,
+      schema[_chunkLHEU4XACjs.ctxSymbol].meta
+    );
+    return innerCheck(schema, receivedValue, ctx);
+  } catch (e) {
+    if (e instanceof _chunkZWFSAKQKjs.ValidationError) throw e;
+    if (e instanceof _chunkZWFSAKQKjs.BuildSchemaError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+function parse(schema, receivedValue, options) {
+  try {
+    const ctx = new ExceptionContext(
+      receivedValue,
+      _chunkZJGY6EOEjs.getTranslationByLocale.call(void 0, _optionalChain([options, 'optionalAccess', _11 => _11.lng])),
+      "",
+      _optionalChain([options, 'optionalAccess', _12 => _12.getAllErrors]) ? [] : void 0,
+      schema[_chunkLHEU4XACjs.ctxSymbol].meta
+    );
+    const parsedValue = innerCheck(schema, receivedValue, ctx);
+    if (_optionalChain([ctx, 'access', _13 => _13.errors, 'optionalAccess', _14 => _14.length])) {
+      return [ctx.errors, null];
+    }
+    return [null, parsedValue];
+  } catch (e) {
+    if (e instanceof _chunkZWFSAKQKjs.ValidationError) {
+      delete e.stack;
+      return [[e], null];
+    }
+    if (e instanceof _chunkZWFSAKQKjs.BuildSchemaError) throw e;
+    return [[unexpectedError()], null];
+  }
+}
+function toStandardResult(result) {
+  const [errors, parsedValue] = result;
+  if (errors) return { issues: errors.map((error) => ({ message: error.message, path: error.path })) };
+  return { value: parsedValue };
+}
+function hasAsyncValidation(schema, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(schema)) return false;
+  seen.add(schema);
+  const schemaData = schema[_chunkLHEU4XACjs.ctxSymbol];
+  if (_optionalChain([schemaData, 'access', _15 => _15.asyncValidations, 'optionalAccess', _16 => _16.length])) return true;
+  const children = [
+    ...schemaData.object ? Object.values(schemaData.object) : [],
+    ..._nullishCoalesce(schemaData.union, () => ( [])),
+    ..._nullishCoalesce(schemaData.tuple, () => ( [])),
+    ...schemaData.array ? [schemaData.array] : [],
+    ...schemaData.record ? [schemaData.record.key, schemaData.record.value] : [],
+    ..._optionalChain([schemaData, 'access', _17 => _17.lazy, 'optionalAccess', _18 => _18.resolved]) ? [schemaData.lazy.resolved] : []
+  ];
+  return children.some((child) => hasAsyncValidation(child, seen));
+}
+function unexpectedError() {
+  return {
+    message: "Something unexpected happened",
+    expected: "",
+    received: "",
+    pathToError: "",
+    path: [],
+    code: "",
+    meta: void 0
+  };
+}
+async function settlePending(pending) {
+  await Promise.all(
+    pending.flatMap(({ validations, received, ctx }) => validations.map((validation) => validation(received, ctx)))
+  );
+}
+async function parseAsync(schema, receivedValue, options) {
+  const errors = [];
+  const pending = [];
+  try {
+    const ctx = new ExceptionContext(
+      receivedValue,
+      _chunkZJGY6EOEjs.getTranslationByLocale.call(void 0, _optionalChain([options, 'optionalAccess', _19 => _19.lng])),
+      "",
+      // Always collecting: a throw partway through would leave the pending validations unawaited.
+      errors,
+      schema[_chunkLHEU4XACjs.ctxSymbol].meta,
+      [],
+      pending
+    );
+    const parsedValue = innerCheck(schema, receivedValue, ctx);
+    await settlePending(pending);
+    if (errors.length) {
+      if (!_optionalChain([options, 'optionalAccess', _20 => _20.getAllErrors])) return [[errors[0]], null];
+      return [errors, null];
+    }
+    return [null, parsedValue];
+  } catch (e) {
+    if (e instanceof _chunkZWFSAKQKjs.BuildSchemaError) throw e;
+    return [[unexpectedError()], null];
+  }
+}
+async function parseOrFailAsync(schema, receivedValue, options) {
+  const [errors, parsedValue] = await parseAsync(schema, receivedValue, options);
+  if (errors) {
+    const [first] = errors;
+    throw new (0, _chunkZWFSAKQKjs.ValidationError)(
+      first.expected,
+      first.received,
+      first.pathToError,
+      first.message,
+      first.meta,
+      first.path,
+      first.code
+    );
+  }
+  return parsedValue;
+}
+
+
+
+
+
+
+
+
+exports.ExceptionContext = ExceptionContext; exports.CommonSchema = CommonSchema; exports.parseOrFail = parseOrFail; exports.parse = parse; exports.parseAsync = parseAsync; exports.parseOrFailAsync = parseOrFailAsync;
+//# sourceMappingURL=chunk-6LUSV3SS.js.map