@warlock.js/notifications 5.2.3 → 5.3.0

package/esm/node_modules/.pnpm/@warlock.js_seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.d.mts

@@ -0,0 +1,492 @@
+import { StandardJSONSchemaV1 } from "../standard-schema/types.mjs";
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ContextualSchemaRule, SchemaRule, SchemaRuleOptions, ValidationAttributesList } from "../types/rule-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { ContextualizedMutator, Mutator } from "../types/mutator-types.mjs";
+import { ContextualizedTransformer, SimpleTransformerCallback, TransformerCallback } from "../types/data-transformer-types.mjs";
+
+//#region ../node_modules/.pnpm/@warlock.js+seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.d.mts
+//#region ../seal/src/validators/base-validator.d.ts
+/**
+ * Base validator class - foundation for all validators
+ */
+declare class BaseValidator<TInput = unknown, TOutput = TInput> {
+  rules: ContextualSchemaRule[];
+  mutators: ContextualizedMutator[];
+  protected defaultValue: any | (() => any);
+  protected description?: string;
+  protected shouldOmit: boolean;
+  protected isNullable: boolean;
+  protected isMutable: boolean;
+  /**
+   * Catch state — when `hasCatch` is true and validation fails, `catchValue`
+   * (or its callback result) substitutes for the failed value, and the public
+   * result reports `isValid: true` with no errors.
+   *
+   * See `.catch()` for semantics and the v1 scope (leaf-only).
+   */
+  protected catchValue: any | ((errors: ValidationResult["errors"], originalInput: any) => any | Promise<any>);
+  protected hasCatch: boolean;
+  /**
+   * Whether the field is optional.
+   * - false (default): field is required unless a requiredRule governs the condition.
+   * - true: field can be absent or empty — set by calling .optional().
+   *
+   * Also used as a TypeScript literal brand via the optional() return type.
+   */
+  isOptional: boolean;
+  /**
+   * The single required-condition rule for this field.
+   * - null: field uses strict default (always required when not optional).
+   * - set: the rule governs when the field is required (e.g., requiredIf).
+   *
+   * Stored separately from rules[] and prepended at validate() time.
+   */
+  requiredRule: ContextualSchemaRule | null;
+  /**
+   * Pipeline to transform the mutated/original data before returning it
+   */
+  protected dataTransformers: ContextualizedTransformer[];
+  /**
+   * Attributes text to be replaced on translations
+   * If the value is an object, it will be used as the attributes list for the rule
+   * If the value is a string, it will be used as the attributes list for the rule
+   */
+  protected attributesText: ValidationAttributesList;
+  /**
+   * Attributed that will be always using the attribute translator
+   */
+  protected translatedAttributes: Record<string, string>;
+  /**
+   * Mark the validator as mutable
+   */
+  get mutable(): this;
+  /**
+   * Mark the validator as immutable
+   */
+  get immutable(): this;
+  /**
+   * Get the instance to apply changes to.
+   * By default (immutable), returns a clone so the original is unchanged.
+   * When `.mutable` is set, returns `this` to mutate in place.
+   */
+  protected get instance(): this;
+  /**
+   * Get the default value
+   * Supports lazy evaluation via callbacks
+   */
+  getDefaultValue(): any;
+  /**
+   * Allow null as a valid value.
+   *
+   * Brands the return type with `{ isNullable: true }` so `Infer<>` widens
+   * the inferred output to include `| null`.
+   */
+  nullable(): this & {
+    isNullable: true;
+  };
+  /**
+   * Explicitly disallow null values after calling nullable.
+   *
+   * Brands the return type with `{ isNullable: false }` to cancel any prior
+   * `.nullable()` at the type level.
+   */
+  notNullable(): this & {
+    isNullable: false;
+  };
+  /**
+   * Add transformer with optional options
+   *
+   * @param transform - The transformer callback function
+   * @param options - Optional options to pass to the transformer
+   *
+   * @example
+   * ```ts
+   * // Without options
+   * v.date().addTransformer(data => data.toISOString())
+   *
+   * // With options
+   * v.date().addTransformer(
+   *   (data, { options }) => dayjs(data).format(options.format),
+   *   { format: 'YYYY-MM-DD' }
+   * )
+   * ```
+   */
+  addTransformer(transform: TransformerCallback, options?: any): this;
+  /**
+   * Add transformer with optional options
+   *
+   * @param transform - The transformer callback function
+   * @param options - Optional options to pass to the transformer
+   *
+   * @example
+   * ```ts
+   * // Without options
+   * v.date().addTransformer(data => data.toISOString())
+   *
+   * // With options
+   * v.date().addTransformer(
+   *   (data, { options }) => dayjs(data).format(options.format),
+   *   { format: 'YYYY-MM-DD' }
+   * )
+   * ```
+   */
+  addMutableTransformer(transform: TransformerCallback, options?: any): void;
+  /**
+   * Transform the output value - simple one-time transformation
+   *
+   * @param callback - Simple callback receiving data and context
+   *
+   * @example
+   * ```ts
+   * // Simple transformation
+   * v.string().outputAs(data => data.toUpperCase())
+   *
+   * // With context
+   * v.string().outputAs((data, context) => {
+   *   console.log(`Transforming ${context.path}`);
+   *   return data.toLowerCase();
+   * })
+   * ```
+   */
+  outputAs(callback: SimpleTransformerCallback): this;
+  /**
+   * Transform output to JSON string
+   *
+   * Works with any validator type (string, number, date, object, array, etc.)
+   *
+   * @param indent - Optional indentation for pretty printing (default: 0 for compact)
+   *
+   * @example
+   * ```ts
+   * // Compact JSON
+   * v.object({ name: v.string() }).toJSON()
+   * // Output: '{"name":"John"}'
+   *
+   * // Pretty-printed JSON
+   * v.array(v.object({...})).toJSON(2)
+   * // Output:
+   * // [
+   * //   {
+   * //     "name": "John"
+   * //   }
+   * // ]
+   *
+   * // Works with any type
+   * v.string().toJSON()  // '"hello"'
+   * v.number().toJSON()  // '42'
+   * v.date().toJSON()    // '"2024-10-26T00:00:00.000Z"'
+   * ```
+   *
+   * @category Transformer
+   */
+  toJSON(indent?: number): this;
+  /**
+   * Start data transformation pipeline
+   * Context is passed at runtime, not stored
+   */
+  startTransformationPipeline(data: any, context: SchemaContext): Promise<any>;
+  /**
+   * Set attributes text to be replaced on translations
+   * If the value is an object, it will be used as the attributes list for the rule
+   * If the value is a string, it will be used as the attributes list for the rule
+   *
+   * @example
+   * v.string().attributes({
+   *   name: "Name",
+   *   email: "Email",
+   * });
+   * // Example 2: Add custom attributes for matches
+   * v.string().matches("confirmPassword").attributes({
+   *   matches: {
+   *     confirmPassword: "Confirm Password",
+   *   },
+   * });
+   */
+  attributes(attributes: Record<string, string | Record<string, string>>): this;
+  /**
+   * Define a lazy getter property for each attribute in the given object and use the config attribute translator
+   */
+  transAttributes(attributes: Record<string, string>): this;
+  /**
+   * Add description to the validator
+   */
+  describe(description: string): this;
+  /**
+   * Check if this validator can handle the given value's type
+   * Override this in specific validators to enable type-based routing in union validators
+   *
+   * Default: returns true (validator will attempt to validate any type)
+   *
+   * @param value - The value to check
+   * @returns True if this validator can handle this type
+   *
+   * @example
+   * ```ts
+   * // StringValidator
+   * public matchesType(value: any): boolean {
+   *   return typeof value === 'string';
+   * }
+   *
+   * // Custom FileValidator
+   * public matchesType(value: any): boolean {
+   *   return value instanceof UploadedFile;
+   * }
+   * ```
+   */
+  matchesType(_value: any): boolean;
+  /**
+   * Create a copy of this validator with the same configuration
+   * Copies all rules, mutators, transformers, default values, and settings
+   *
+   * @returns A new validator instance with copied configuration
+   *
+   * @example
+   * ```ts
+   * // Create reusable validator templates
+   * const baseString = v.string().required().trim().min(3);
+   * const emailField = baseString.clone().email();
+   * const usernameField = baseString.clone().alphanumeric().max(20);
+   *
+   * // Works with all validators
+   * const positiveInt = v.int().positive().required();
+   * const ageField = positiveInt.clone().min(18).max(120);
+   * ```
+   */
+  clone(): this;
+  /**
+   * @deprecated This method is no longer needed and does nothing.
+   * Empty values are now automatically skipped for validation rules by default.
+   * Only presence validators (required, present, etc.) will check empty values.
+   * You can safely remove this call from your code.
+   */
+  ignoreEmptyValue(_ignoreEmptyValue?: boolean): this;
+  /**
+   * Omit this field from the validated data output
+   *
+   * Field will still be validated but not included in the final result.
+   * Useful for confirmation fields, captcha, terms acceptance, etc.
+   *
+   * @example
+   * ```ts
+   * v.object({
+   *   password: v.string().required(),
+   *   confirmPassword: v.string().required().sameAs("password").omit(),
+   *   acceptTerms: v.boolean().required().omit(),
+   * });
+   * // Output: { password: "..." }
+   * // confirmPassword and acceptTerms validated but omitted
+   * ```
+   */
+  omit(): this;
+  /**
+   * @alias omit
+   */
+  exclude(): this;
+  /**
+   * Check if this field should be omitted from the output
+   */
+  isOmitted(): boolean;
+  /**
+   * Add rule to the validator
+   */
+  addRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): this;
+  /**
+   * Set the required-condition rule for this field.
+   *
+   * Unlike addRule(), this does NOT push to rules[]. The rule is stored in the
+   * dedicated `requiredRule` slot and is prepended to the validation pipeline
+   * at runtime. Only one required rule can be active per field — this replaces
+   * any previously set required rule.
+   *
+   * Also marks the field as not optional (isOptional = false).
+   *
+   * @example
+   * ```ts
+   * // Used internally by required(), requiredIf(), requiredWith(), etc.
+   * BaseValidator.prototype.required = function(msg) {
+   *   return this.setRequiredRule(requiredRule, msg);
+   * };
+   * ```
+   */
+  setRequiredRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): this;
+  /**
+   * Add mutable rule
+   */
+  addMutableRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): ContextualSchemaRule<T>;
+  /**
+   * Create new rule
+   */
+  protected createRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): ContextualSchemaRule<T>;
+  /**
+   * Use a custom or pre-built validation rule
+   *
+   * @param rule - The validation rule to apply
+   * @param options - Rule options including errorMessage and any rule-specific options
+   *
+   * @example
+   * ```ts
+   * import { hexColorRule } from "@warlock.js/seal";
+   *
+   * v.string().useRule(hexColorRule, { errorMessage: "Invalid color" });
+   * ```
+   *
+   * @example
+   * ```ts
+   * // With rule options
+   * v.string().useRule(myCustomRule, {
+   *   customOption: true,
+   *   errorMessage: "Custom validation failed"
+   * });
+   * ```
+   */
+  useRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, options?: T & {
+    errorMessage?: string;
+  }): this;
+  /**
+   * Define custom rule
+   */
+  refine(callback: (value: any, context: SchemaContext) => Promise<string | undefined> | string | undefined): this;
+  /**
+   * Add mutator to the validator
+   */
+  addMutator(mutator: Mutator, options?: any): this;
+  /**
+   * Add mutable mutator
+   */
+  addMutableMutator(mutator: Mutator, options?: any): void;
+  /**
+   * Set default value for the field. The default is used when the input is
+   * absent (`undefined`); it then flows through the rule pipeline.
+   *
+   * Brands the return type with `{ hasDefault: true }` so `Infer<>` treats
+   * the field as guaranteed-present even when chained with `.optional()`.
+   */
+  default(value: any): this & {
+    hasDefault: true;
+  };
+  /**
+   * Fallback to a value when validation fails.
+   *
+   * Complementary to `.default()`: `.default(x)` fires when input is **absent**,
+   * `.catch(y)` fires when input is **present but invalid**. Combine them when
+   * you want both behaviours: `.optional().default(x).catch(y)`.
+   *
+   * The fallback can be a value or a callback `(errors, originalInput) => fallback`.
+   * The callback variant is the only side-channel for the swallowed errors —
+   * use it to log/alert before the fallback substitutes.
+   *
+   * Brands the return type with `{ hasCatch: true }` so `Infer<>` treats the
+   * field as guaranteed-present (the catch ensures a value will always exist).
+   *
+   * **Scope (v1).** Catch is honoured for **leaf validators** (string, number,
+   * boolean, date, …) and for fields inside containers. It is a **no-op on
+   * container validators themselves** (`v.object`, `v.array`, `v.record`,
+   * `v.tuple`, `v.discriminatedUnion`) — those use their own iteration logic
+   * that bypasses the catch hook in `BaseValidator.validate()`.
+   *
+   * @example
+   * ```ts
+   * v.int().min(0).catch(3)                   // bad number → 3
+   * v.string().in(["us", "eu"]).catch("us")   // unknown enum → "us"
+   * v.string().catch((errors, input) => {
+   *   console.warn(`bad user value: ${JSON.stringify(input)}`, errors);
+   *   return "anonymous";
+   * })
+   * ```
+   */
+  catch(fallback: any | ((errors: ValidationResult["errors"], originalInput: any) => any | Promise<any>)): this & {
+    hasCatch: true;
+  };
+  /**
+   * Mutate the data
+   */
+  mutate(data: any, context: SchemaContext): Promise<any>;
+  /**
+   * Set the label for the validator that will be matching the :input attribute
+   */
+  label(label: string): this;
+  /**
+   * Validate the data
+   */
+  validate(data: any, context: SchemaContext): Promise<ValidationResult>;
+  /**
+   * Set rule attributes list
+   */
+  protected setRuleAttributesList(rule: ContextualSchemaRule): void;
+  /**
+   * Standard Schema V1 compliance.
+   *
+   * Allows this validator to be used with any Standard Schema-aware library
+   * (OpenAI structured outputs, LangGraph, TanStack Form, Conform, Valibot adapters, etc.)
+   * without extra adapters.
+   *
+   * Delegates to the `validate()` factory so all `configureSeal()` options
+   * (translations, firstErrorOnly) are picked up automatically at call time.
+   *
+   * Includes Standard JSON Schema support via `jsonSchema.input()` / `jsonSchema.output()`.
+   *
+   * ## How Standard Schema libraries consume this
+   *
+   * You pass the **schema object itself** to the library — they internally read
+   * `schema["~standard"]`. Do NOT pass `schema["~standard"]` directly.
+   *
+   * @example
+   * ```ts
+   * const schema = v.object({ name: v.string().required() });
+   *
+   * // TanStack Form — pass schema, library reads ["~standard"] internally
+   * const form = useForm({ validators: { onChange: schema } });
+   *
+   * // Conform (Remix) — same pattern
+   * const [form] = useForm({ onValidate({ formData }) {
+   *   return parseWithStandardSchema(formData, { schema });
+   * }});
+   *
+   * // Direct validation (lower level — most apps don't need this)
+   * const result = await schema["~standard"].validate({ name: "Hasan" });
+   * // → { value: { name: "Hasan" } }  on success
+   * // → { issues: [{ message: "...", path: [{ key: "name" }] }] }  on failure
+   *
+   * // JSON Schema for OpenAI / LangChain tool calling
+   * const parameters = schema["~standard"].jsonSchema.input({ target: "openai-strict" });
+   * // → { type: "object", properties: {...}, required: [...], additionalProperties: false }
+   * ```
+   *
+   * @note Cross-field rules (sameAs, requiredIf, requiredWith) rely on sibling values
+   * available in the full validation context. When called on a standalone scalar validator,
+   * sibling data is absent and those rules will not evaluate correctly.
+   * Always call on the parent ObjectValidator for full-payload validation.
+   */
+  get ["~standard"](): StandardJSONSchemaV1.Props<TInput, TOutput>;
+  /**
+   * Generate a JSON Schema representation of this validator.
+   *
+   * Supports targets: `"draft-2020-12"` (default), `"draft-07"`, `"openapi-3.0"`.
+   *
+   * Subclasses override this to describe their specific constraints.
+   * The base implementation returns `{}` (permissive — accepts anything),
+   * which is correct for validators with no representable JSON Schema constraints.
+   *
+   * @note Rules that cannot be expressed in JSON Schema are silently omitted:
+   * - Cross-field rules: sameAs, requiredIf, requiredWith, requiredWithout
+   * - Custom callbacks: refine()
+   * - Framework-specific runtime rules (core/cascade plugins)
+   * These rules still run normally at validation time — only absent from JSON Schema.
+   *
+   * @example
+   * ```ts
+   * v.string().min(3).max(50).toJsonSchema("draft-2020-12")
+   * // → { type: "string", minLength: 3, maxLength: 50 }
+   *
+   * v.object({ name: v.string().required(), age: v.int().optional() })
+   *   .toJsonSchema("draft-07")
+   * // → { type: "object", properties: { name: { type: "string" }, age: { type: "integer" } }, required: ["name"] }
+   * ```
+   */
+  toJsonSchema(_target?: JsonSchemaTarget): JsonSchemaResult;
+} //#endregion
+//#endregion
+export { BaseValidator };
+//# sourceMappingURL=base-validator.d.mts.map

package/esm/node_modules/.pnpm/@warlock.js_seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-validator.d.mts","names":["TInput","TOutput","rules","ContextualSchemaRule","mutators","ContextualizedMutator","defaultValue","description","shouldOmit","isNullable","isMutable","catchValue","ValidationResult","errors","originalInput","Promise","hasCatch","isOptional","requiredRule","dataTransformers","ContextualizedTransformer","attributesText","ValidationAttributesList","translatedAttributes","Record","mutable","immutable","instance","getDefaultValue","nullable","notNullable","addTransformer","TransformerCallback","transform","options","addMutableTransformer","outputAs","SimpleTransformerCallback","callback","toJSON","indent","startTransformationPipeline","data","SchemaContext","context","attributes","transAttributes","describe","matchesType","_value","clone","ignoreEmptyValue","_ignoreEmptyValue","omit","exclude","isOmitted","addRule","T","SchemaRuleOptions","SchemaRule","rule","errorMessage","setRequiredRule","addMutableRule","createRule","useRule","refine","value","addMutator","Mutator","mutator","addMutableMutator","default","hasDefault","catch","fallback","mutate","label","validate","setRuleAttributesList","StandardJSONSchemaV1","Props","toJsonSchema","JsonSchemaTarget","_target","JsonSchemaResult"],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@warlock.js+seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.d.mts"],"x_google_ignoreList":[0],"mappings":"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"}

package/esm/{seal/src → node_modules/.pnpm/@warlock.js_seal@5.2.4/node_modules/@warlock.js/seal/esm}/validators/base-validator.mjs

@@ -1,63 +1,30 @@
-import { clone } from "../../../node_modules/.pnpm/@mongez_reinforcements@4.0.1/node_modules/@mongez/reinforcements/esm/mixed/clone/clone.mjs";
-import "../../../node_modules/.pnpm/@mongez_reinforcements@4.0.1/node_modules/@mongez/reinforcements/esm/index.mjs";
 import { validate } from "../factory/validate.mjs";
+import { clone } from "../../../../../../@mongez_reinforcements@4.0.1/node_modules/@mongez/reinforcements/esm/mixed/clone/clone.mjs";
+import "../../../../../../@mongez_reinforcements@4.0.1/node_modules/@mongez/reinforcements/esm/index.mjs";
 import { VALID_RULE, invalidRule } from "../helpers/validation-helpers.mjs";
 import "../helpers/index.mjs";
 import { isEmptyValue } from "../helpers/is-empty-value.mjs";
 import { requiredRule } from "../rules/core/required.mjs";
 import { mapToStandardResult } from "../standard-schema/map-result.mjs";
 
-//#region ../seal/src/validators/base-validator.ts
+//#region ../node_modules/.pnpm/@warlock.js+seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.mjs
 /**
 * Base validator class - foundation for all validators
 */
 var BaseValidator = class {
-	rules = [];
-	mutators = [];
-	defaultValue;
-	description;
-	shouldOmit = false;
-	isNullable = false;
-	isMutable = false;
-	/**
-	* Catch state — when `hasCatch` is true and validation fails, `catchValue`
-	* (or its callback result) substitutes for the failed value, and the public
-	* result reports `isValid: true` with no errors.
-	*
-	* See `.catch()` for semantics and the v1 scope (leaf-only).
-	*/
-	catchValue;
-	hasCatch = false;
-	/**
-	* Whether the field is optional.
-	* - false (default): field is required unless a requiredRule governs the condition.
-	* - true: field can be absent or empty — set by calling .optional().
-	*
-	* Also used as a TypeScript literal brand via the optional() return type.
-	*/
-	isOptional = false;
-	/**
-	* The single required-condition rule for this field.
-	* - null: field uses strict default (always required when not optional).
-	* - set: the rule governs when the field is required (e.g., requiredIf).
-	*
-	* Stored separately from rules[] and prepended at validate() time.
-	*/
-	requiredRule = this.createRule(requiredRule);
-	/**
-	* Pipeline to transform the mutated/original data before returning it
-	*/
-	dataTransformers = [];
-	/**
-	* Attributes text to be replaced on translations
-	* If the value is an object, it will be used as the attributes list for the rule
-	* If the value is a string, it will be used as the attributes list for the rule
-	*/
-	attributesText = {};
-	/**
-	* Attributed that will be always using the attribute translator
-	*/
-	translatedAttributes = {};
+	constructor() {
+		this.rules = [];
+		this.mutators = [];
+		this.shouldOmit = false;
+		this.isNullable = false;
+		this.isMutable = false;
+		this.hasCatch = false;
+		this.isOptional = false;
+		this.requiredRule = this.createRule(requiredRule);
+		this.dataTransformers = [];
+		this.attributesText = {};
+		this.translatedAttributes = {};
+	}
 	/**
 	* Mark the validator as mutable
 	*/

package/esm/node_modules/.pnpm/@warlock.js_seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-validator.mjs","names":[],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@warlock.js+seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/base-validator.mjs"],"sourcesContent":["import { validate } from \"../factory/validate.mjs\";\nimport { VALID_RULE, invalidRule } from \"../helpers/validation-helpers.mjs\";\nimport \"../helpers/index.mjs\";\nimport { isEmptyValue } from \"../helpers/is-empty-value.mjs\";\nimport { requiredRule } from \"../rules/core/required.mjs\";\nimport { mapToStandardResult } from \"../standard-schema/map-result.mjs\";\nimport { clone } from \"@mongez/reinforcements\";\n\n//#region ../seal/src/validators/base-validator.ts\n/**\n* Base validator class - foundation for all validators\n*/\nvar BaseValidator = class {\n\tconstructor() {\n\t\tthis.rules = [];\n\t\tthis.mutators = [];\n\t\tthis.shouldOmit = false;\n\t\tthis.isNullable = false;\n\t\tthis.isMutable = false;\n\t\tthis.hasCatch = false;\n\t\tthis.isOptional = false;\n\t\tthis.requiredRule = this.createRule(requiredRule);\n\t\tthis.dataTransformers = [];\n\t\tthis.attributesText = {};\n\t\tthis.translatedAttributes = {};\n\t}\n\t/**\n\t* Mark the validator as mutable\n\t*/\n\tget mutable() {\n\t\tthis.isMutable = true;\n\t\treturn this;\n\t}\n\t/**\n\t* Mark the validator as immutable\n\t*/\n\tget immutable() {\n\t\tthis.isMutable = false;\n\t\treturn this;\n\t}\n\t/**\n\t* Get the instance to apply changes to.\n\t* By default (immutable), returns a clone so the original is unchanged.\n\t* When `.mutable` is set, returns `this` to mutate in place.\n\t*/\n\tget instance() {\n\t\treturn this.isMutable ? this : this.clone();\n\t}\n\t/**\n\t* Get the default value\n\t* Supports lazy evaluation via callbacks\n\t*/\n\tgetDefaultValue() {\n\t\treturn typeof this.defaultValue === \"function\" ? this.defaultValue() : this.defaultValue;\n\t}\n\t/**\n\t* Allow null as a valid value.\n\t*\n\t* Brands the return type with `{ isNullable: true }` so `Infer<>` widens\n\t* the inferred output to include `| null`.\n\t*/\n\tnullable() {\n\t\tconst instance = this.instance;\n\t\tinstance.isNullable = true;\n\t\treturn instance;\n\t}\n\t/**\n\t* Explicitly disallow null values after calling nullable.\n\t*\n\t* Brands the return type with `{ isNullable: false }` to cancel any prior\n\t* `.nullable()` at the type level.\n\t*/\n\tnotNullable() {\n\t\tconst instance = this.instance;\n\t\tinstance.isNullable = false;\n\t\treturn instance;\n\t}\n\t/**\n\t* Add transformer with optional options\n\t*\n\t* @param transform - The transformer callback function\n\t* @param options - Optional options to pass to the transformer\n\t*\n\t* @example\n\t* ```ts\n\t* // Without options\n\t* v.date().addTransformer(data => data.toISOString())\n\t*\n\t* // With options\n\t* v.date().addTransformer(\n\t*   (data, { options }) => dayjs(data).format(options.format),\n\t*   { format: 'YYYY-MM-DD' }\n\t* )\n\t* ```\n\t*/\n\taddTransformer(transform, options = {}) {\n\t\tconst instance = this.instance;\n\t\tinstance.addMutableTransformer(transform, options);\n\t\treturn instance;\n\t}\n\t/**\n\t* Add transformer with optional options\n\t*\n\t* @param transform - The transformer callback function\n\t* @param options - Optional options to pass to the transformer\n\t*\n\t* @example\n\t* ```ts\n\t* // Without options\n\t* v.date().addTransformer(data => data.toISOString())\n\t*\n\t* // With options\n\t* v.date().addTransformer(\n\t*   (data, { options }) => dayjs(data).format(options.format),\n\t*   { format: 'YYYY-MM-DD' }\n\t* )\n\t* ```\n\t*/\n\taddMutableTransformer(transform, options = {}) {\n\t\tthis.dataTransformers.push({\n\t\t\ttransform,\n\t\t\toptions\n\t\t});\n\t}\n\t/**\n\t* Transform the output value - simple one-time transformation\n\t*\n\t* @param callback - Simple callback receiving data and context\n\t*\n\t* @example\n\t* ```ts\n\t* // Simple transformation\n\t* v.string().outputAs(data => data.toUpperCase())\n\t*\n\t* // With context\n\t* v.string().outputAs((data, context) => {\n\t*   console.log(`Transforming ${context.path}`);\n\t*   return data.toLowerCase();\n\t* })\n\t* ```\n\t*/\n\toutputAs(callback) {\n\t\treturn this.addTransformer((data, { context }) => callback(data, context));\n\t}\n\t/**\n\t* Transform output to JSON string\n\t*\n\t* Works with any validator type (string, number, date, object, array, etc.)\n\t*\n\t* @param indent - Optional indentation for pretty printing (default: 0 for compact)\n\t*\n\t* @example\n\t* ```ts\n\t* // Compact JSON\n\t* v.object({ name: v.string() }).toJSON()\n\t* // Output: '{\"name\":\"John\"}'\n\t*\n\t* // Pretty-printed JSON\n\t* v.array(v.object({...})).toJSON(2)\n\t* // Output:\n\t* // [\n\t* //   {\n\t* //     \"name\": \"John\"\n\t* //   }\n\t* // ]\n\t*\n\t* // Works with any type\n\t* v.string().toJSON()  // '\"hello\"'\n\t* v.number().toJSON()  // '42'\n\t* v.date().toJSON()    // '\"2024-10-26T00:00:00.000Z\"'\n\t* ```\n\t*\n\t* @category Transformer\n\t*/\n\ttoJSON(indent) {\n\t\treturn this.addTransformer((data, { options }) => JSON.stringify(data, null, options.indent), { indent: indent ?? 0 });\n\t}\n\t/**\n\t* Start data transformation pipeline\n\t* Context is passed at runtime, not stored\n\t*/\n\tasync startTransformationPipeline(data, context) {\n\t\tfor (const transformer of this.dataTransformers) data = await transformer.transform(data, {\n\t\t\toptions: transformer.options,\n\t\t\tcontext\n\t\t});\n\t\treturn data;\n\t}\n\t/**\n\t* Set attributes text to be replaced on translations\n\t* If the value is an object, it will be used as the attributes list for the rule\n\t* If the value is a string, it will be used as the attributes list for the rule\n\t*\n\t* @example\n\t* v.string().attributes({\n\t*   name: \"Name\",\n\t*   email: \"Email\",\n\t* });\n\t* // Example 2: Add custom attributes for matches\n\t* v.string().matches(\"confirmPassword\").attributes({\n\t*   matches: {\n\t*     confirmPassword: \"Confirm Password\",\n\t*   },\n\t* });\n\t*/\n\tattributes(attributes) {\n\t\tconst instance = this.instance;\n\t\tfor (const key in attributes) instance.attributesText[key] = attributes[key];\n\t\treturn instance;\n\t}\n\t/**\n\t* Define a lazy getter property for each attribute in the given object and use the config attribute translator\n\t*/\n\ttransAttributes(attributes) {\n\t\tconst instance = this.instance;\n\t\tfor (const key in attributes) instance.translatedAttributes[key] = attributes[key];\n\t\treturn instance;\n\t}\n\t/**\n\t* Add description to the validator\n\t*/\n\tdescribe(description) {\n\t\tconst instance = this.instance;\n\t\tinstance.description = description;\n\t\treturn instance;\n\t}\n\t/**\n\t* Check if this validator can handle the given value's type\n\t* Override this in specific validators to enable type-based routing in union validators\n\t*\n\t* Default: returns true (validator will attempt to validate any type)\n\t*\n\t* @param value - The value to check\n\t* @returns True if this validator can handle this type\n\t*\n\t* @example\n\t* ```ts\n\t* // StringValidator\n\t* public matchesType(value: any): boolean {\n\t*   return typeof value === 'string';\n\t* }\n\t*\n\t* // Custom FileValidator\n\t* public matchesType(value: any): boolean {\n\t*   return value instanceof UploadedFile;\n\t* }\n\t* ```\n\t*/\n\tmatchesType(_value) {\n\t\treturn true;\n\t}\n\t/**\n\t* Create a copy of this validator with the same configuration\n\t* Copies all rules, mutators, transformers, default values, and settings\n\t*\n\t* @returns A new validator instance with copied configuration\n\t*\n\t* @example\n\t* ```ts\n\t* // Create reusable validator templates\n\t* const baseString = v.string().required().trim().min(3);\n\t* const emailField = baseString.clone().email();\n\t* const usernameField = baseString.clone().alphanumeric().max(20);\n\t*\n\t* // Works with all validators\n\t* const positiveInt = v.int().positive().required();\n\t* const ageField = positiveInt.clone().min(18).max(120);\n\t* ```\n\t*/\n\tclone() {\n\t\tconst Constructor = this.constructor;\n\t\tconst cloned = Object.create(Constructor.prototype);\n\t\tcloned.rules = [...this.rules];\n\t\tcloned.mutators = [...this.mutators];\n\t\tcloned.dataTransformers = [...this.dataTransformers];\n\t\tcloned.defaultValue = this.defaultValue;\n\t\tcloned.shouldOmit = this.shouldOmit;\n\t\tcloned.description = this.description;\n\t\tcloned.attributesText = { ...this.attributesText };\n\t\tcloned.isNullable = this.isNullable;\n\t\tcloned.isOptional = this.isOptional;\n\t\tcloned.requiredRule = this.requiredRule;\n\t\tcloned.catchValue = this.catchValue;\n\t\tcloned.hasCatch = this.hasCatch;\n\t\treturn cloned;\n\t}\n\t/**\n\t* @deprecated This method is no longer needed and does nothing.\n\t* Empty values are now automatically skipped for validation rules by default.\n\t* Only presence validators (required, present, etc.) will check empty values.\n\t* You can safely remove this call from your code.\n\t*/\n\tignoreEmptyValue(_ignoreEmptyValue = true) {\n\t\treturn this;\n\t}\n\t/**\n\t* Omit this field from the validated data output\n\t*\n\t* Field will still be validated but not included in the final result.\n\t* Useful for confirmation fields, captcha, terms acceptance, etc.\n\t*\n\t* @example\n\t* ```ts\n\t* v.object({\n\t*   password: v.string().required(),\n\t*   confirmPassword: v.string().required().sameAs(\"password\").omit(),\n\t*   acceptTerms: v.boolean().required().omit(),\n\t* });\n\t* // Output: { password: \"...\" }\n\t* // confirmPassword and acceptTerms validated but omitted\n\t* ```\n\t*/\n\tomit() {\n\t\tconst instance = this.instance;\n\t\tinstance.shouldOmit = true;\n\t\treturn instance;\n\t}\n\t/**\n\t* @alias omit\n\t*/\n\texclude() {\n\t\treturn this.omit();\n\t}\n\t/**\n\t* Check if this field should be omitted from the output\n\t*/\n\tisOmitted() {\n\t\treturn this.shouldOmit;\n\t}\n\t/**\n\t* Add rule to the validator\n\t*/\n\taddRule(rule, errorMessage, options = {}) {\n\t\tconst instance = this.instance;\n\t\tinstance.addMutableRule(rule, errorMessage, options);\n\t\treturn instance;\n\t}\n\t/**\n\t* Set the required-condition rule for this field.\n\t*\n\t* Unlike addRule(), this does NOT push to rules[]. The rule is stored in the\n\t* dedicated `requiredRule` slot and is prepended to the validation pipeline\n\t* at runtime. Only one required rule can be active per field — this replaces\n\t* any previously set required rule.\n\t*\n\t* Also marks the field as not optional (isOptional = false).\n\t*\n\t* @example\n\t* ```ts\n\t* // Used internally by required(), requiredIf(), requiredWith(), etc.\n\t* BaseValidator.prototype.required = function(msg) {\n\t*   return this.setRequiredRule(requiredRule, msg);\n\t* };\n\t* ```\n\t*/\n\tsetRequiredRule(rule, errorMessage, options = {}) {\n\t\tconst instance = this.instance;\n\t\tinstance.isOptional = false;\n\t\tinstance.requiredRule = instance.createRule(rule, errorMessage, options);\n\t\treturn instance;\n\t}\n\t/**\n\t* Add mutable rule\n\t*/\n\taddMutableRule(rule, errorMessage, options = {}) {\n\t\tconst newRule = this.createRule(rule, errorMessage, options);\n\t\tthis.rules.push(newRule);\n\t\treturn newRule;\n\t}\n\t/**\n\t* Create new rule\n\t*/\n\tcreateRule(rule, errorMessage, options = {}) {\n\t\tconst newRule = {\n\t\t\t...clone(rule),\n\t\t\tcontext: {\n\t\t\t\terrorMessage,\n\t\t\t\toptions,\n\t\t\t\tattributesList: this.attributesText,\n\t\t\t\ttranslatedAttributes: this.translatedAttributes,\n\t\t\t\ttranslationParams: {},\n\t\t\t\ttranslatableParams: {}\n\t\t\t}\n\t\t};\n\t\tif (errorMessage) newRule.errorMessage = errorMessage;\n\t\tif (rule.sortOrder === void 0) newRule.sortOrder = this.rules.length + 1;\n\t\treturn newRule;\n\t}\n\t/**\n\t* Use a custom or pre-built validation rule\n\t*\n\t* @param rule - The validation rule to apply\n\t* @param options - Rule options including errorMessage and any rule-specific options\n\t*\n\t* @example\n\t* ```ts\n\t* import { hexColorRule } from \"@warlock.js/seal\";\n\t*\n\t* v.string().useRule(hexColorRule, { errorMessage: \"Invalid color\" });\n\t* ```\n\t*\n\t* @example\n\t* ```ts\n\t* // With rule options\n\t* v.string().useRule(myCustomRule, {\n\t*   customOption: true,\n\t*   errorMessage: \"Custom validation failed\"\n\t* });\n\t* ```\n\t*/\n\tuseRule(rule, options) {\n\t\tconst { errorMessage, ...ruleOptions } = options || {};\n\t\treturn this.addRule(rule, errorMessage, ruleOptions);\n\t}\n\t/**\n\t* Define custom rule\n\t*/\n\trefine(callback) {\n\t\treturn this.addRule({\n\t\t\tname: \"custom\",\n\t\t\tasync validate(value, context) {\n\t\t\t\tconst result = await callback(value, context);\n\t\t\t\tif (result) {\n\t\t\t\t\tthis.context.errorMessage = result;\n\t\t\t\t\treturn invalidRule(this, context);\n\t\t\t\t}\n\t\t\t\treturn VALID_RULE;\n\t\t\t}\n\t\t});\n\t}\n\t/**\n\t* Add mutator to the validator\n\t*/\n\taddMutator(mutator, options = {}) {\n\t\tconst instance = this.instance;\n\t\tinstance.addMutableMutator(mutator, options);\n\t\treturn instance;\n\t}\n\t/**\n\t* Add mutable mutator\n\t*/\n\taddMutableMutator(mutator, options = {}) {\n\t\tthis.mutators.push({\n\t\t\tmutate: mutator,\n\t\t\tcontext: {\n\t\t\t\toptions,\n\t\t\t\tctx: {}\n\t\t\t}\n\t\t});\n\t}\n\t/**\n\t* Set default value for the field. The default is used when the input is\n\t* absent (`undefined`); it then flows through the rule pipeline.\n\t*\n\t* Brands the return type with `{ hasDefault: true }` so `Infer<>` treats\n\t* the field as guaranteed-present even when chained with `.optional()`.\n\t*/\n\tdefault(value) {\n\t\tconst instance = this.instance;\n\t\tinstance.defaultValue = value;\n\t\treturn instance;\n\t}\n\t/**\n\t* Fallback to a value when validation fails.\n\t*\n\t* Complementary to `.default()`: `.default(x)` fires when input is **absent**,\n\t* `.catch(y)` fires when input is **present but invalid**. Combine them when\n\t* you want both behaviours: `.optional().default(x).catch(y)`.\n\t*\n\t* The fallback can be a value or a callback `(errors, originalInput) => fallback`.\n\t* The callback variant is the only side-channel for the swallowed errors —\n\t* use it to log/alert before the fallback substitutes.\n\t*\n\t* Brands the return type with `{ hasCatch: true }` so `Infer<>` treats the\n\t* field as guaranteed-present (the catch ensures a value will always exist).\n\t*\n\t* **Scope (v1).** Catch is honoured for **leaf validators** (string, number,\n\t* boolean, date, …) and for fields inside containers. It is a **no-op on\n\t* container validators themselves** (`v.object`, `v.array`, `v.record`,\n\t* `v.tuple`, `v.discriminatedUnion`) — those use their own iteration logic\n\t* that bypasses the catch hook in `BaseValidator.validate()`.\n\t*\n\t* @example\n\t* ```ts\n\t* v.int().min(0).catch(3)                   // bad number → 3\n\t* v.string().in([\"us\", \"eu\"]).catch(\"us\")   // unknown enum → \"us\"\n\t* v.string().catch((errors, input) => {\n\t*   console.warn(`bad user value: ${JSON.stringify(input)}`, errors);\n\t*   return \"anonymous\";\n\t* })\n\t* ```\n\t*/\n\tcatch(fallback) {\n\t\tconst instance = this.instance;\n\t\tinstance.catchValue = fallback;\n\t\tinstance.hasCatch = true;\n\t\treturn instance;\n\t}\n\t/**\n\t* Mutate the data\n\t*/\n\tasync mutate(data, context) {\n\t\tlet mutatedData = data;\n\t\tfor (const mutator of this.mutators) {\n\t\t\tmutator.context.ctx = context;\n\t\t\tmutatedData = await mutator.mutate(mutatedData, mutator.context);\n\t\t}\n\t\treturn mutatedData;\n\t}\n\t/**\n\t* Set the label for the validator that will be matching the :input attribute\n\t*/\n\tlabel(label) {\n\t\tconst instance = this.instance;\n\t\tinstance.attributesText.input = label;\n\t\treturn instance;\n\t}\n\t/**\n\t* Validate the data\n\t*/\n\tasync validate(data, context) {\n\t\tif (data === null && this.isNullable) return {\n\t\t\tisValid: true,\n\t\t\terrors: [],\n\t\t\tdata: null\n\t\t};\n\t\tconst valueForRules = data ?? this.getDefaultValue();\n\t\tconst mutatedData = await this.mutate(valueForRules, context);\n\t\tconst errors = [];\n\t\tlet isValid = true;\n\t\tconst isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;\n\t\tconst isEmpty = isEmptyValue(valueForRules);\n\t\tconst skipEmptyRules = this.isOptional ? valueForRules === void 0 : isEmpty;\n\t\tconst rulesToRun = this.requiredRule ? [this.requiredRule, ...this.rules] : this.rules;\n\t\tfor (const rule of rulesToRun) {\n\t\t\tif ((rule.requiresValue ?? true) && skipEmptyRules) continue;\n\t\t\tthis.setRuleAttributesList(rule);\n\t\t\tconst result = await rule.validate(mutatedData, context);\n\t\t\tif (result.isValid === false) {\n\t\t\t\tisValid = false;\n\t\t\t\terrors.push({\n\t\t\t\t\ttype: rule.name,\n\t\t\t\t\terror: result.error,\n\t\t\t\t\tinput: result.path ?? context.path\n\t\t\t\t});\n\t\t\t\tif (isFirstErrorOnly) break;\n\t\t\t}\n\t\t}\n\t\tconst result = {\n\t\t\tisValid,\n\t\t\terrors,\n\t\t\tdata: mutatedData !== void 0 ? await this.startTransformationPipeline(mutatedData, context) : void 0\n\t\t};\n\t\tif (result.isValid === false && this.hasCatch) return {\n\t\t\tisValid: true,\n\t\t\terrors: [],\n\t\t\tdata: typeof this.catchValue === \"function\" ? await this.catchValue(result.errors, data) : this.catchValue\n\t\t};\n\t\treturn result;\n\t}\n\t/**\n\t* Set rule attributes list\n\t*/\n\tsetRuleAttributesList(rule) {\n\t\trule.context.attributesList = typeof this.attributesText[rule.name] === \"object\" ? this.attributesText[rule.name] : this.attributesText;\n\t}\n\t/**\n\t* Standard Schema V1 compliance.\n\t*\n\t* Allows this validator to be used with any Standard Schema-aware library\n\t* (OpenAI structured outputs, LangGraph, TanStack Form, Conform, Valibot adapters, etc.)\n\t* without extra adapters.\n\t*\n\t* Delegates to the `validate()` factory so all `configureSeal()` options\n\t* (translations, firstErrorOnly) are picked up automatically at call time.\n\t*\n\t* Includes Standard JSON Schema support via `jsonSchema.input()` / `jsonSchema.output()`.\n\t*\n\t* ## How Standard Schema libraries consume this\n\t*\n\t* You pass the **schema object itself** to the library — they internally read\n\t* `schema[\"~standard\"]`. Do NOT pass `schema[\"~standard\"]` directly.\n\t*\n\t* @example\n\t* ```ts\n\t* const schema = v.object({ name: v.string().required() });\n\t*\n\t* // TanStack Form — pass schema, library reads [\"~standard\"] internally\n\t* const form = useForm({ validators: { onChange: schema } });\n\t*\n\t* // Conform (Remix) — same pattern\n\t* const [form] = useForm({ onValidate({ formData }) {\n\t*   return parseWithStandardSchema(formData, { schema });\n\t* }});\n\t*\n\t* // Direct validation (lower level — most apps don't need this)\n\t* const result = await schema[\"~standard\"].validate({ name: \"Hasan\" });\n\t* // → { value: { name: \"Hasan\" } }  on success\n\t* // → { issues: [{ message: \"...\", path: [{ key: \"name\" }] }] }  on failure\n\t*\n\t* // JSON Schema for OpenAI / LangChain tool calling\n\t* const parameters = schema[\"~standard\"].jsonSchema.input({ target: \"openai-strict\" });\n\t* // → { type: \"object\", properties: {...}, required: [...], additionalProperties: false }\n\t* ```\n\t*\n\t* @note Cross-field rules (sameAs, requiredIf, requiredWith) rely on sibling values\n\t* available in the full validation context. When called on a standalone scalar validator,\n\t* sibling data is absent and those rules will not evaluate correctly.\n\t* Always call on the parent ObjectValidator for full-payload validation.\n\t*/\n\tget [\"~standard\"]() {\n\t\treturn {\n\t\t\tversion: 1,\n\t\t\tvendor: \"seal\",\n\t\t\ttypes: void 0,\n\t\t\tvalidate: async (value) => {\n\t\t\t\treturn mapToStandardResult(await validate(this, value));\n\t\t\t},\n\t\t\tjsonSchema: {\n\t\t\t\tinput: (options) => this.toJsonSchema(options.target),\n\t\t\t\toutput: (options) => this.toJsonSchema(options.target)\n\t\t\t}\n\t\t};\n\t}\n\t/**\n\t* Generate a JSON Schema representation of this validator.\n\t*\n\t* Supports targets: `\"draft-2020-12\"` (default), `\"draft-07\"`, `\"openapi-3.0\"`.\n\t*\n\t* Subclasses override this to describe their specific constraints.\n\t* The base implementation returns `{}` (permissive — accepts anything),\n\t* which is correct for validators with no representable JSON Schema constraints.\n\t*\n\t* @note Rules that cannot be expressed in JSON Schema are silently omitted:\n\t* - Cross-field rules: sameAs, requiredIf, requiredWith, requiredWithout\n\t* - Custom callbacks: refine()\n\t* - Framework-specific runtime rules (core/cascade plugins)\n\t* These rules still run normally at validation time — only absent from JSON Schema.\n\t*\n\t* @example\n\t* ```ts\n\t* v.string().min(3).max(50).toJsonSchema(\"draft-2020-12\")\n\t* // → { type: \"string\", minLength: 3, maxLength: 50 }\n\t*\n\t* v.object({ name: v.string().required(), age: v.int().optional() })\n\t*   .toJsonSchema(\"draft-07\")\n\t* // → { type: \"object\", properties: { name: { type: \"string\" }, age: { type: \"integer\" } }, required: [\"name\"] }\n\t* ```\n\t*/\n\ttoJsonSchema(_target = \"draft-2020-12\") {\n\t\treturn {};\n\t}\n};\n\n//#endregion\nexport { BaseValidator };\n//# sourceMappingURL=base-validator.mjs.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/esm/{seal/src → node_modules/.pnpm/@warlock.js_seal@5.2.4/node_modules/@warlock.js/seal/esm}/validators/boolean-validator.mjs

@@ -6,7 +6,7 @@ import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, accepted
 import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "../rules/scalar/declined-rule.mjs";
 import "../rules/scalar/index.mjs";
 
-//#region ../seal/src/validators/boolean-validator.ts
+//#region ../node_modules/.pnpm/@warlock.js+seal@5.2.4/node_modules/@warlock.js/seal/esm/validators/boolean-validator.mjs
 /**
 * Boolean validator class
 *