@warlock.js/seal 5.30.0 → 5.32.0

package/esm/types/mutator-types.d.mts

@@ -1,27 +1,29 @@
 import { SchemaContext } from "./context-types.mjs";
-
 //#region ../../packages/seal/src/types/mutator-types.d.ts
 /**
  * Mutator context
  */
-type MutatorContext<Options = any> = {
-  /** Mutator options */options: Options; /** Global validation context */
+export type MutatorContext<Options = any> = {
+  /** Mutator options */
+  options: Options;
+  /** Global validation context */
   ctx: SchemaContext;
 };
 /**
  * Mutator function - transforms data before validation
  */
-type Mutator<Options = any> = (data: any, context?: MutatorContext<Options>) => Promise<any>;
+export type Mutator<Options = any> = (data: any, context?: MutatorContext<Options>) => Promise<any>;
 /**
  * Contextualized mutator - mutator with runtime context
  */
-type ContextualizedMutator<Options = any> = {
-  /** Mutation function */mutate: Mutator<Options>; /** Mutator context */
+export type ContextualizedMutator<Options = any> = {
+  /** Mutation function */
+  mutate: Mutator<Options>;
+  /** Mutator context */
   context: {
     options: Options;
     ctx: SchemaContext;
   };
 };
 //#endregion
-export { ContextualizedMutator, Mutator, MutatorContext };
 //# sourceMappingURL=mutator-types.d.mts.map

package/esm/types/mutator-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mutator-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/mutator-types.ts"],"mappings":";;;;;AAKA;KAAY,cAAA;EAAc,sBAExB,OAAA,EAAS,OAAA,EAFgB;EAIzB,GAAA,EAAK,aAAa;AAAA;;;;KAMR,OAAA,mBAA0B,IAAA,OAAW,OAAA,GAAU,cAAA,CAAe,OAAA,MAAa,OAAA;AAAvF;;;AAAA,KAKY,qBAAA;EAL+C,wBAOzD,MAAA,EAAQ,OAAA,CAAQ,OAAA,GAP4E;EAS5F,OAAA;IACE,OAAA,EAAS,OAAA;IACT,GAAA,EAAK,aAAA;EAAA;AAAA"}
+{"version":3,"file":"mutator-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/mutator-types.ts"],"mappings":";;;;;YAKY,eAAe;;EAEzB,SAAS;;EAET,KAAK;;;;;YAMK,QAAQ,kBAAkB,WAAW,UAAU,eAAe,aAAa;;;;YAK3E,sBAAsB;;EAEhC,QAAQ,QAAQ;;EAEhB;IACE,SAAS;IACT,KAAK"}

package/esm/types/result-types.d.mts

@@ -2,12 +2,18 @@
 /**
  * Validation result
  */
-type ValidationResult = {
-  /** Whether validation passed */isValid: boolean; /** Validated and potentially mutated data */
-  data: any; /** List of validation errors */
+export type ValidationResult = {
+  /** Whether validation passed */
+  isValid: boolean;
+  /** Validated and potentially mutated data */
+  data: any;
+  /** List of validation errors */
   errors: {
-    /** Rule type that failed */type: string; /** Error message */
-    error: string; /** Input field name */
+    /** Rule type that failed */
+    type: string;
+    /** Error message */
+    error: string;
+    /** Input field name */
     input: string;
   }[];
 };
@@ -26,7 +32,7 @@ type ValidationResult = {
  * result.data; // Infer.Output<typeof schema>
  * ```
  */
-type TypedValidationResult<TData> = {
+export type TypedValidationResult<TData> = {
   isValid: true;
   data: TData;
   errors: ValidationResult["errors"];
@@ -36,5 +42,4 @@ type TypedValidationResult<TData> = {
   errors: ValidationResult["errors"];
 };
 //#endregion
-export { TypedValidationResult, ValidationResult };
 //# sourceMappingURL=result-types.d.mts.map

package/esm/types/result-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/result-types.ts"],"mappings":";;AAGA;;KAAY,gBAAA;EAAgB,gCAE1B,OAAA,WAEA;EAAA,IAAA,OAIE;EAFF,MAAA;IAME,4BAJA,IAAA,UAIK;IAFL,KAAA,UAqB6B;IAnB7B,KAAA;EAAA;AAAA;;;;;;;;;;;;;;;AAqB2D;KAFnD,qBAAA;EACN,OAAA;EAAe,IAAA,EAAM,KAAA;EAAO,MAAA,EAAQ,gBAAA;AAAA;EACpC,OAAA;EAAgB,IAAA;EAAiB,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"result-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/result-types.ts"],"mappings":";;;;YAGY;;EAEV;;EAEA;;EAEA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;YAmBQ,sBAAsB;EAC5B;EAAe,MAAM;EAAO,QAAQ;;EACpC;EAAgB;EAAiB,QAAQ"}

package/esm/types/rule-types.d.mts

@@ -1,39 +1,55 @@
 import { SchemaContext } from "./context-types.mjs";
-
 //#region ../../packages/seal/src/types/rule-types.d.ts
 /**
  * Rule validation result
  */
-type RuleResult = {
+export type RuleResult = {
   isValid: false;
   error: string;
   input: string;
   path: string;
+  /**
+   * Report several errors for this rule, each at its own path. When set,
+   * it replaces `error`/`path` in the validation result.
+   */
+  errors?: Array<{
+    error: string;
+    path: string;
+  }>;
 } | {
   isValid: true;
+  /** Replace the validated value, including an explicit undefined output. */
+  data?: unknown;
 };
 type AttributeValue = string | number;
-type ValidationAttributesList = Record<string, AttributeValue | Record<string, AttributeValue>>;
+export type ValidationAttributesList = Record<string, AttributeValue | Record<string, AttributeValue>>;
 /**
  * Rule options - generic options passed to rules
  */
-type SchemaRuleOptions<T = any> = Record<string, T>;
+export type SchemaRuleOptions<T = any> = Record<string, T>;
 /**
  * Schema rule definition
  */
-type SchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = {
-  /** Rule name */name: string; /** Rule description */
-  description?: string; /** Whether the rule requires a non-undefined value */
-  requiresValue?: boolean; /** Validation function */
-  validate: (this: ContextualSchemaRule<Options>, value: any, context: SchemaContext) => Promise<RuleResult>; /** Default error message */
-  defaultErrorMessage?: string; /** Error message */
-  errorMessage?: string; /** Sort order for rule execution */
+export type SchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = {
+  /** Rule name */
+  name: string;
+  /** Rule description */
+  description?: string;
+  /** Whether the rule requires a non-undefined value */
+  requiresValue?: boolean;
+  /** Validation function */
+  validate: (this: ContextualSchemaRule<Options>, value: any, context: SchemaContext) => Promise<RuleResult>;
+  /** Default error message */
+  defaultErrorMessage?: string;
+  /** Error message */
+  errorMessage?: string;
+  /** Sort order for rule execution */
   sortOrder?: number;
 };
 /**
  * Contextualized schema rule - rule with runtime context
  */
-type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = SchemaRule & {
+export type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = SchemaRule & {
   /**
    * The context object is used to pass additional information to the rule
    * This will be always overridden when the rule is injected into a validator
@@ -42,11 +58,13 @@ type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions>
     errorMessage?: string;
     options: Options;
     attributesList: ValidationAttributesList;
-    translatedAttributes: Record<string, string>; /** Raw placeholder values — substituted as-is (enums, numbers, computed strings) */
-    translationParams: Record<string, any>; /** Field-key placeholder values — passed through the attribute translator before substitution */
+    translatedAttributes: Record<string, string>;
+    /** Raw placeholder values — substituted as-is (enums, numbers, computed strings) */
+    translationParams: Record<string, any>;
+    /** Field-key placeholder values — passed through the attribute translator before substitution */
     translatableParams: Record<string, string>;
   };
 };
 //#endregion
-export { ContextualSchemaRule, RuleResult, SchemaRule, SchemaRuleOptions, ValidationAttributesList };
+export {};
 //# sourceMappingURL=rule-types.d.mts.map

package/esm/types/rule-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/rule-types.ts"],"mappings":";;;;;AAKA;KAAY,UAAA;EAEN,OAAA;EACA,KAAA;EACA,KAAA;EACA,IAAA;AAAA;EAGA,OAAA;AAAA;AAAA,KAGD,cAAA;AAAA,KAEO,wBAAA,GAA2B,MAAA,SAErC,cAAA,GAAiB,MAAA,SAAe,cAAA;AAN5B;;;AAAA,KAYM,iBAAA,YAA6B,MAAM,SAAS,CAAA;AAVrC;AAEnB;;AAFmB,KAeP,UAAA,iBAA2B,iBAAA,GAAoB,iBAAA;EAXzD,gBAaA,IAAA,UAbiB;EAejB,WAAA,WAjB2C;EAmB3C,aAAA,YAnBqC;EAqBrC,QAAA,GACE,IAAA,EAAM,oBAAA,CAAqB,OAAA,GAC3B,KAAA,OACA,OAAA,EAAS,aAAA,KACN,OAAA,CAAQ,UAAA,GAvBI;EAyBjB,mBAAA,WAzB8C;EA2B9C,YAAA,WArBU;EAuBV,SAAA;AAAA;;;;KAMU,oBAAA,iBAAqC,iBAAA,GAAoB,iBAAA,IACnE,UAAA;EA9BuD;AAAA;AAKzD;;EA8BI,OAAA;IACE,YAAA;IACA,OAAA,EAAS,OAAA;IACT,cAAA,EAAgB,wBAAA;IAChB,oBAAA,EAAsB,MAAA,kBAvBf;IAyBP,iBAAA,EAAmB,MAAA,eAxBlB;IA0BD,kBAAA,EAAoB,MAAA;EAAA;AAAA"}
+{"version":3,"file":"rule-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/rule-types.ts"],"mappings":";;;;;YAKY;EAEN;EACA;EACA;EACA;;;;;EAKA,SAAS;IAAQ;IAAe;;;EAGhC;;EAEA;;KAGD;YAEO,2BAA2B,eAErC,iBAAiB,eAAe;;;;YAMtB,kBAAkB,WAAW,eAAe;;;;YAK5C,WAAW,gBAAgB,oBAAoB;;EAEzD;;EAEA;;EAEA;;EAEA,WACE,MAAM,qBAAqB,UAC3B,YACA,SAAS,kBACN,QAAQ;;EAEb;;EAEA;;EAEA;;;;;YAMU,qBAAqB,gBAAgB,oBAAoB,qBACnE;;;;;EAKE;IACE;IACA,SAAS;IACT,gBAAgB;IAChB,sBAAsB;;IAEtB,mBAAmB;;IAEnB,oBAAoB"}

package/esm/types/schema-types.d.mts

@@ -1,10 +1,8 @@
 import { BaseValidator } from "../validators/base-validator.mjs";
-
 //#region ../../packages/seal/src/types/schema-types.d.ts
 /**
  * Schema definition - a record of validators
  */
-type Schema = Record<string, BaseValidator>;
+export type Schema = Record<string, BaseValidator>;
 //#endregion
-export { Schema };
 //# sourceMappingURL=schema-types.d.mts.map

package/esm/types/schema-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/schema-types.ts"],"mappings":";;;;;AAKA;KAAY,MAAA,GAAS,MAAM,SAAS,aAAA"}
+{"version":3,"file":"schema-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/schema-types.ts"],"mappings":";;;;;YAKY,SAAS,eAAe"}

package/esm/validators/any-validator.d.mts

@@ -1,11 +1,10 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/any-validator.d.ts
 /**
  * Any validator - accepts any value
  */
-declare class AnyValidator extends BaseValidator {
+export declare class AnyValidator extends BaseValidator {
   /**
    * Any validator means any value, so we disable the default required requirement.
    */
@@ -29,5 +28,4 @@ declare class AnyValidator extends BaseValidator {
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { AnyValidator };
 //# sourceMappingURL=any-validator.d.mts.map

package/esm/validators/any-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"any-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/any-validator.ts"],"mappings":";;;;;;AAOA;cAAa,YAAA,SAAqB,aAAA;;;;EAIhB,YAAA;EAJ6B;;;EAS7B,UAAA;EAAA;;;;;;AAc0E;;;;;;EAA1E,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"any-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/any-validator.ts"],"mappings":";;;;;;qBAOa,qBAAqB;;;;EAIhB;;;;EAKA;;;;;;;;;;;;;EAcA,aAAa,SAAQ,mBAAqC"}

package/esm/validators/array-validator.d.mts

@@ -1,13 +1,13 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { SchemaContext } from "../types/context-types.mjs";
 import { ValidationResult } from "../types/result-types.mjs";
+import "../types/index.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/array-validator.d.ts
 /**
  * Array validator class
  */
-declare class ArrayValidator extends BaseValidator {
+export declare class ArrayValidator extends BaseValidator {
   validator: BaseValidator;
   constructor(validator: BaseValidator, errorMessage?: string);
   /**
@@ -82,5 +82,4 @@ declare class ArrayValidator extends BaseValidator {
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { ArrayValidator };
 //# sourceMappingURL=array-validator.d.mts.map

package/esm/validators/array-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"mappings":";;;;;;;;;cAmBa,cAAA,SAAuB,aAAA;EAEzB,SAAA,EAAW,aAAA;cAAX,SAAA,EAAW,aAAA,EAClB,YAAA;EADkB;;;EAWb,WAAA,CAAY,KAAA;EA8G+C;;;EAvGlD,KAAA;EApBkB;EA6B3B,IAAA;EA7BwC;EAkCxC,OAAA;EAhCE;EAqCF,UAAA;;EAKA,IAAA,CAAK,SAAA,mBAAmC,GAAA;EA1CtC;EA+CF,GAAA,CAAI,GAAA,UAAa,YAAA;EApCjB;EAyCA,SAAA,CAAU,MAAA,UAAgB,YAAA;EAlCjB;EAuCT,GAAA,CAAI,GAAA,UAAa,YAAA;EAzBjB;EA8BA,SAAA,CAAU,MAAA,UAAgB,YAAA;EApB1B;EAyBA,MAAA,CAAO,MAAA,UAAgB,YAAA;EAzBiB;;;;;;;;;;;;;;EA2CxC,OAAA,CAAQ,GAAA,UAAa,GAAA,UAAa,YAAA;EAlBX;;;EA4BvB,aAAA,CAAc,GAAA,UAAa,GAAA,UAAa,YAAA;EAVN;EAelC,MAAA,CAAO,YAAA;EALO;EAUd,MAAA,CAAO,SAAA,mBAAmC,YAAA;EAVF;EAexC,MAAA,CAAO,IAAA,OAAW,OAAA,EAAS,aAAA;EAVpB;;;;;;EAqBD,QAAA,CAAS,IAAA,OAAW,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,gBAAA;EAXzC;;;;;;;;;;;EAwET,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"array-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"mappings":";;;;;;;;;qBAmBa,uBAAuB;EAEzB,WAAW;EADpB,YACS,WAAW,eAClB;;;;EAUK,YAAY;;;;EAOH;;EAST;;EAKA;;EAKA;;EAKA,KAAK,4BAAmC;;EAKxC,IAAI,aAAa;;EAKjB,UAAU,gBAAgB;;EAK1B,IAAI,aAAa;;EAKjB,UAAU,gBAAgB;;EAK1B,OAAO,gBAAgB;;;;;;;;;;;;;;;EAkBvB,QAAQ,aAAa,aAAa;;;;EAUlC,cAAc,aAAa,aAAa;;EAKxC,OAAO;;EAKP,OAAO,4BAAmC;;EAK1C,OAAO,WAAW,SAAS;;;;;;;EAWrB,SAAS,WAAW,SAAS,gBAAgB,QAAQ;;;;;;;;;;;;EAgElD,aAAa,SAAQ,mBAAqC"}

package/esm/validators/array-validator.mjs

@@ -121,7 +121,7 @@ var ArrayValidator = class extends BaseValidator {
 	async validate(data, context) {
 		const valueForRules = data ?? this.getDefaultValue();
 		const mutatedData = await this.mutate(valueForRules, context);
-		const result = await super.validate(data, context);
+		const result = await this.validateRules(data, context);
 		if (result.isValid === false) return result;
 		if (mutatedData === void 0 || mutatedData === null) return result;
 		if (!Array.isArray(mutatedData)) return result;
@@ -139,11 +139,11 @@ var ArrayValidator = class extends BaseValidator {
 			if (childResult.isValid === false) errors.push(...childResult.errors);
 		});
 		await Promise.all(validationPromises);
-		return {
+		return this.refineResult({
 			isValid: errors.length === 0,
 			errors,
 			data: await this.startTransformationPipeline(mutatedData, context)
-		};
+		}, context);
 	}
 	/**
 	* @inheritdoc

package/esm/validators/array-validator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"sourcesContent":["import { setKeyPath } from \"../helpers\";\nimport { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from \"../mutators\";\nimport {\n  arrayRule,\n  betweenLengthRule,\n  lengthRule,\n  maxLengthRule,\n  minLengthRule,\n  sortedArrayRule,\n  uniqueArrayRule,\n} from \"../rules\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Array validator class\n */\nexport class ArrayValidator extends BaseValidator {\n  public constructor(\n    public validator: BaseValidator,\n    errorMessage?: string,\n  ) {\n    super();\n    this.blankIsMissing = true;\n    this.addMutableRule(arrayRule, errorMessage);\n  }\n\n  /**\n   * Check if value is an array type\n   */\n  public matchesType(value: any): boolean {\n    return Array.isArray(value);\n  }\n\n  /**\n   * Clone the validator\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n\n    cloned.validator = this.validator.clone();\n\n    return cloned;\n  }\n\n  /** Reverse array order */\n  public flip() {\n    return this.addMutator(flipArrayMutator);\n  }\n\n  /** Reverse array order (alias) */\n  public reverse() {\n    return this.addMutator(flipArrayMutator);\n  }\n\n  /** Make it has only unique values */\n  public onlyUnique() {\n    return this.addMutator(uniqueArrayMutator);\n  }\n\n  /** Sort array */\n  public sort(direction: \"asc\" | \"desc\" = \"asc\", key?: string) {\n    return this.addMutator(sortArrayMutator, { direction, key });\n  }\n\n  /** Array length must be greater than the given length */\n  public min(min: number, errorMessage?: string) {\n    return this.addRule(minLengthRule, errorMessage, { minLength: min });\n  }\n\n  /** @alias min */\n  public minLength(length: number, errorMessage?: string) {\n    return this.min(length, errorMessage);\n  }\n\n  /** Array length must be less than the given length */\n  public max(max: number, errorMessage?: string) {\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: max });\n  }\n\n  /** @alias max */\n  public maxLength(length: number, errorMessage?: string) {\n    return this.max(length, errorMessage);\n  }\n\n  /** Array length must be of the given length */\n  public length(length: number, errorMessage?: string) {\n    return this.addRule(lengthRule, errorMessage, { length });\n  }\n\n  /**\n   * Array length must be between min and max (inclusive)\n   *\n   * @param min - Minimum length (inclusive)\n   * @param max - Maximum length (inclusive)\n   *\n   * @example\n   * ```ts\n   * v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items\n   * v.array(v.number()).lengthBetween(5, 20)  // Same using alias\n   * ```\n   *\n   * @category Validation Rule\n   */\n  public between(min: number, max: number, errorMessage?: string) {\n    return this.addRule(betweenLengthRule, errorMessage, {\n      minLength: min,\n      maxLength: max,\n    });\n  }\n\n  /**\n   * Alias for between() - array length between min and max\n   */\n  public lengthBetween(min: number, max: number, errorMessage?: string) {\n    return this.between(min, max, errorMessage);\n  }\n\n  /** Array must have unique values */\n  public unique(errorMessage?: string) {\n    return this.addRule(uniqueArrayRule, errorMessage);\n  }\n\n  /** Array must be sorted */\n  public sorted(direction: \"asc\" | \"desc\" = \"asc\", errorMessage?: string) {\n    return this.addRule(sortedArrayRule, errorMessage, { direction });\n  }\n\n  /** Mutate the data */\n  public mutate(data: any, context: SchemaContext) {\n    if (!Array.isArray(data)) return data;\n    return super.mutate([...data], context);\n  }\n\n  /** Validate array\n   *\n   * Absent input (and absent without `.default()`) propagates as `data: undefined`\n   * so the parent ObjectValidator can omit the key. Without this, optional array\n   * fields would silently materialise as `[]` in the validated output.\n   */\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    // Apply default when absent, then mutate. Mirrors BaseValidator's\n    // `valueForRules = data ?? this.getDefaultValue()` so `.default([...])`\n    // works on arrays too.\n    const valueForRules = data ?? this.getDefaultValue();\n    const mutatedData = await this.mutate(valueForRules, context);\n\n    const result = await super.validate(data, context);\n\n    if (result.isValid === false) return result;\n\n    // Nothing to iterate for absent (no default) or null (nullable) inputs —\n    // propagate so the parent ObjectValidator can omit the key.\n    if (mutatedData === undefined || mutatedData === null) return result;\n\n    // Defensive: type rule (arrayRule) should have failed for non-arrays.\n    if (!Array.isArray(mutatedData)) return result;\n\n    const errors: ValidationResult[\"errors\"] = [];\n\n    // Validate all items in parallel (consistent with ObjectValidator)\n    const validationPromises = mutatedData.map(async (value: any, index: number) => {\n      const childContext: SchemaContext = {\n        ...context,\n        parent: mutatedData,\n        value,\n        key: index.toString(),\n        path: setKeyPath(context.path, index.toString()),\n      };\n\n      const childResult = await this.validator.validate(value, childContext);\n\n      // Update mutated data with validated result\n      mutatedData[index] = childResult.data;\n\n      // Collect errors from this element\n      if (childResult.isValid === false) {\n        errors.push(...childResult.errors);\n      }\n    });\n\n    await Promise.all(validationPromises);\n\n    return {\n      isValid: errors.length === 0,\n      errors,\n      data: await this.startTransformationPipeline(mutatedData, context),\n    };\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Recursively generates JSON Schema for the array items.\n   *\n   * @example\n   * ```ts\n   * v.array(v.string().min(1)).minLength(1).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"array\", items: { type: \"string\", minLength: 1 }, minItems: 1 }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult = {\n      type: \"array\",\n      items: this.validator.toJsonSchema(target),\n    };\n\n    const minOpts = getRuleOptions(this.rules, \"minLength\");\n    if (minOpts?.minLength !== undefined) schema.minItems = minOpts.minLength;\n\n    const maxOpts = getRuleOptions(this.rules, \"maxLength\");\n    if (maxOpts?.maxLength !== undefined) schema.maxItems = maxOpts.maxLength;\n\n    const betweenOpts = getRuleOptions(this.rules, \"betweenLength\");\n    if (betweenOpts) {\n      if (betweenOpts.minLength !== undefined) schema.minItems = betweenOpts.minLength;\n      if (betweenOpts.maxLength !== undefined) schema.maxItems = betweenOpts.maxLength;\n    }\n\n    const lengthOpts = getRuleOptions(this.rules, \"length\");\n    if (lengthOpts?.length !== undefined) {\n      schema.minItems = lengthOpts.length;\n      schema.maxItems = lengthOpts.length;\n    }\n\n    if (this.isNullable) applyNullable(schema, target);\n\n    return schema;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"array-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"sourcesContent":["import { setKeyPath } from \"../helpers\";\nimport { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from \"../mutators\";\nimport {\n  arrayRule,\n  betweenLengthRule,\n  lengthRule,\n  maxLengthRule,\n  minLengthRule,\n  sortedArrayRule,\n  uniqueArrayRule,\n} from \"../rules\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Array validator class\n */\nexport class ArrayValidator extends BaseValidator {\n  public constructor(\n    public validator: BaseValidator,\n    errorMessage?: string,\n  ) {\n    super();\n    this.blankIsMissing = true;\n    this.addMutableRule(arrayRule, errorMessage);\n  }\n\n  /**\n   * Check if value is an array type\n   */\n  public matchesType(value: any): boolean {\n    return Array.isArray(value);\n  }\n\n  /**\n   * Clone the validator\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n\n    cloned.validator = this.validator.clone();\n\n    return cloned;\n  }\n\n  /** Reverse array order */\n  public flip() {\n    return this.addMutator(flipArrayMutator);\n  }\n\n  /** Reverse array order (alias) */\n  public reverse() {\n    return this.addMutator(flipArrayMutator);\n  }\n\n  /** Make it has only unique values */\n  public onlyUnique() {\n    return this.addMutator(uniqueArrayMutator);\n  }\n\n  /** Sort array */\n  public sort(direction: \"asc\" | \"desc\" = \"asc\", key?: string) {\n    return this.addMutator(sortArrayMutator, { direction, key });\n  }\n\n  /** Array length must be greater than the given length */\n  public min(min: number, errorMessage?: string) {\n    return this.addRule(minLengthRule, errorMessage, { minLength: min });\n  }\n\n  /** @alias min */\n  public minLength(length: number, errorMessage?: string) {\n    return this.min(length, errorMessage);\n  }\n\n  /** Array length must be less than the given length */\n  public max(max: number, errorMessage?: string) {\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: max });\n  }\n\n  /** @alias max */\n  public maxLength(length: number, errorMessage?: string) {\n    return this.max(length, errorMessage);\n  }\n\n  /** Array length must be of the given length */\n  public length(length: number, errorMessage?: string) {\n    return this.addRule(lengthRule, errorMessage, { length });\n  }\n\n  /**\n   * Array length must be between min and max (inclusive)\n   *\n   * @param min - Minimum length (inclusive)\n   * @param max - Maximum length (inclusive)\n   *\n   * @example\n   * ```ts\n   * v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items\n   * v.array(v.number()).lengthBetween(5, 20)  // Same using alias\n   * ```\n   *\n   * @category Validation Rule\n   */\n  public between(min: number, max: number, errorMessage?: string) {\n    return this.addRule(betweenLengthRule, errorMessage, {\n      minLength: min,\n      maxLength: max,\n    });\n  }\n\n  /**\n   * Alias for between() - array length between min and max\n   */\n  public lengthBetween(min: number, max: number, errorMessage?: string) {\n    return this.between(min, max, errorMessage);\n  }\n\n  /** Array must have unique values */\n  public unique(errorMessage?: string) {\n    return this.addRule(uniqueArrayRule, errorMessage);\n  }\n\n  /** Array must be sorted */\n  public sorted(direction: \"asc\" | \"desc\" = \"asc\", errorMessage?: string) {\n    return this.addRule(sortedArrayRule, errorMessage, { direction });\n  }\n\n  /** Mutate the data */\n  public mutate(data: any, context: SchemaContext) {\n    if (!Array.isArray(data)) return data;\n    return super.mutate([...data], context);\n  }\n\n  /** Validate array\n   *\n   * Absent input (and absent without `.default()`) propagates as `data: undefined`\n   * so the parent ObjectValidator can omit the key. Without this, optional array\n   * fields would silently materialise as `[]` in the validated output.\n   */\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    // Apply default when absent, then mutate. Mirrors BaseValidator's\n    // `valueForRules = data ?? this.getDefaultValue()` so `.default([...])`\n    // works on arrays too.\n    const valueForRules = data ?? this.getDefaultValue();\n    const mutatedData = await this.mutate(valueForRules, context);\n\n    const result = await this.validateRules(data, context);\n\n    if (result.isValid === false) return result;\n\n    // Nothing to iterate for absent (no default) or null (nullable) inputs —\n    // propagate so the parent ObjectValidator can omit the key.\n    if (mutatedData === undefined || mutatedData === null) return result;\n\n    // Defensive: type rule (arrayRule) should have failed for non-arrays.\n    if (!Array.isArray(mutatedData)) return result;\n\n    const errors: ValidationResult[\"errors\"] = [];\n\n    // Validate all items in parallel (consistent with ObjectValidator)\n    const validationPromises = mutatedData.map(async (value: any, index: number) => {\n      const childContext: SchemaContext = {\n        ...context,\n        parent: mutatedData,\n        value,\n        key: index.toString(),\n        path: setKeyPath(context.path, index.toString()),\n      };\n\n      const childResult = await this.validator.validate(value, childContext);\n\n      // Update mutated data with validated result\n      mutatedData[index] = childResult.data;\n\n      // Collect errors from this element\n      if (childResult.isValid === false) {\n        errors.push(...childResult.errors);\n      }\n    });\n\n    await Promise.all(validationPromises);\n\n    return this.refineResult(\n      {\n        isValid: errors.length === 0,\n        errors,\n        data: await this.startTransformationPipeline(mutatedData, context),\n      },\n      context,\n    );\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Recursively generates JSON Schema for the array items.\n   *\n   * @example\n   * ```ts\n   * v.array(v.string().min(1)).minLength(1).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"array\", items: { type: \"string\", minLength: 1 }, minItems: 1 }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult = {\n      type: \"array\",\n      items: this.validator.toJsonSchema(target),\n    };\n\n    const minOpts = getRuleOptions(this.rules, \"minLength\");\n    if (minOpts?.minLength !== undefined) schema.minItems = minOpts.minLength;\n\n    const maxOpts = getRuleOptions(this.rules, \"maxLength\");\n    if (maxOpts?.maxLength !== undefined) schema.maxItems = maxOpts.maxLength;\n\n    const betweenOpts = getRuleOptions(this.rules, \"betweenLength\");\n    if (betweenOpts) {\n      if (betweenOpts.minLength !== undefined) schema.minItems = betweenOpts.minLength;\n      if (betweenOpts.maxLength !== undefined) schema.maxItems = betweenOpts.maxLength;\n    }\n\n    const lengthOpts = getRuleOptions(this.rules, \"length\");\n    if (lengthOpts?.length !== undefined) {\n      schema.minItems = lengthOpts.length;\n      schema.maxItems = lengthOpts.length;\n    }\n\n    if (this.isNullable) applyNullable(schema, target);\n\n    return schema;\n  }\n}\n"],"mappings":"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"}

package/esm/validators/base-validator.d.mts

@@ -5,13 +5,14 @@ import { SchemaContext } from "../types/context-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";
-
+import "../types/index.mjs";
 //#region ../../packages/seal/src/validators/base-validator.d.ts
 /**
  * Base validator class - foundation for all validators
  */
-declare class BaseValidator<TInput = unknown, TOutput = TInput> {
+export declare class BaseValidator<TInput = unknown, TOutput = TInput> {
   rules: ContextualSchemaRule[];
+  protected refinements: ContextualSchemaRule[];
   mutators: ContextualizedMutator[];
   protected defaultValue: any | (() => any);
   protected description?: string;
@@ -346,15 +347,12 @@ declare class BaseValidator<TInput = unknown, TOutput = TInput> {
     errorMessage?: string;
   }): this;
   /**
-   * Define custom rule
-   *
-   * `value` is deliberately untyped: custom rules run in the rule pipeline,
-   * before a container validates its children (an object's fields are not yet
-   * validated or defaulted) and, when `firstErrorOnly` is `false` (the default
-   * is `true`), even after the type rule has failed. Typing it as the schema
-   * output would promise a shape the callback does not always receive.
+   * Validate the successful output after type rules, children and transformers.
+   * Refinements are skipped for absent/null values and failed validation.
    */
-  refine(callback: (value: any, context: SchemaContext) => Promise<string | undefined> | string | undefined): this;
+  refine(callback: (value: NonNullable<this["~standard"]["types"]>["output"], context: SchemaContext) => Promise<string | undefined> | string | undefined): this;
+  /** Complete validation only after the entire output is available. */
+  protected refineResult(result: ValidationResult, context: SchemaContext): Promise<ValidationResult>;
   /**
    * Add mutator to the validator
    */
@@ -418,6 +416,8 @@ declare class BaseValidator<TInput = unknown, TOutput = TInput> {
    * Validate the data
    */
   validate(data: any, context: SchemaContext): Promise<ValidationResult>;
+  /** Validate presence and value rules before containers descend into children. */
+  protected validateRules(data: any, context: SchemaContext): Promise<ValidationResult>;
   /**
    * Set rule attributes list
    */
@@ -495,5 +495,4 @@ declare class BaseValidator<TInput = unknown, TOutput = TInput> {
   toJsonSchema(_target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { BaseValidator };
 //# sourceMappingURL=base-validator.d.mts.map

package/esm/validators/base-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"base-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/base-validator.ts"],"mappings":"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"}
+{"version":3,"file":"base-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/base-validator.ts"],"mappings":";;;;;;;;;;;;qBAyBa,cAAc,kBAAkB,UAAU;EAC9C,OAAO;YACJ,aAAa;EAChB,UAAU;YACP;YACA;YACA;YACA;YACA;;YAEA;;;;;;;;YASA,oBAEJ,QAAQ,4BAA4B,6BAA6B;YAC7D;;;;;;;;EASH;;;;;;;;EASA,cAAc;;;;YAKX,kBAAkB;;;;;;YAOlB,gBAAgB;;;;YAKhB,sBAAsB;;;;MAKrB;;;;MAQA;;;;;;gBAUG;;;;;EAQP;;;;;;;EAUA;IAAqB;;;;;;;;EAYrB;IAAwB;;;;;;;;;;;;;;;;;;;;EAwBxB,eAAe,WAAW,qBAAqB;;;;;;;;;;;;;;;;;;;EAyB/C,sBAAsB,WAAW,qBAAqB;;;;;;;;;;;;;;;;;;EAwBtD,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCnB,OAAO;;;;;EAUD,4BAA4B,WAAW,SAAS,gBAAa;;;;;;;;;;;;;;;;;;EA4BnE,WAAW,YAAY,wBAAwB;;;;EAY/C,gBAAgB,YAAY;;;;EAY5B,SAAS;;;;;;;;;;;;;;;;;;;;;;;EA4BT,YAAY;;;;;;;;;;;;;;;;;;;EAsBZ;;;;;;;EA+BA,iBAAiB;;;;;;;;;;;;;;;;;;EAsBjB;;;;EASA;;;;EAOA;;;;EAOA,QAAQ,UAAU,oBAAoB,mBAC3C,MAAM,WAAW,IACjB,uBACA,UAAS;;;;;;;;;;;;;;;;;;;EAyBJ,gBAAgB,UAAU,oBAAoB,mBACnD,MAAM,WAAW,IACjB,uBACA,UAAS;;;;EAWJ,eAAe,UAAU,oBAAoB,mBAClD,MAAM,WAAW,IACjB,uBACA,UAAS,IACR,qBAAqB;;;;YAWd,WAAW,UAAU,oBAAoB,mBACjD,MAAM,WAAW,IACjB,uBACA,UAAS,IACR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;EA8CjB,QAAQ,UAAU,oBAAoB,mBAC3C,MAAM,WAAW,IACjB,UAAU;IAAM;;;;;;EAUX,OACL,WACE,OAAO,mDACP,SAAS,kBACN;;YAoBS,aACd,QAAQ,kBACR,SAAS,gBACR,QAAQ;;;;EAkBJ,WAAW,SAAS,SAAS;;;;EAS7B,kBAAkB,SAAS,SAAS;;;;;;;;EAiBpC,QAAQ;IAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC9B,MACL,kBAEM,QAAQ,4BAA4B,6BAA6B;IAC7D;;;;;EAYC,OAAO,WAAW,SAAS,gBAAa;;;;EAc9C,MAAM;;;;EASA,SAAS,WAAW,SAAS,gBAAgB,QAAQ;;YAclD,cAAc,WAAW,SAAS,gBAAgB,QAAQ;;;;YA8HhE,sBAAsB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAoDjB,qBAAqB,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCjD,aAAa,UAAS,mBAAqC"}

package/esm/validators/base-validator.mjs

@@ -12,6 +12,7 @@ import { clone } from "@mongez/reinforcements";
 var BaseValidator = class {
 	constructor() {
 		this.rules = [];
+		this.refinements = [];
 		this.mutators = [];
 		this.shouldOmit = false;
 		this.isNullable = false;
@@ -271,6 +272,7 @@ var BaseValidator = class {
 		const Constructor = this.constructor;
 		const cloned = Object.create(Constructor.prototype);
 		cloned.rules = [...this.rules];
+		cloned.refinements = [...this.refinements];
 		cloned.mutators = [...this.mutators];
 		cloned.dataTransformers = [...this.dataTransformers];
 		cloned.defaultValue = this.defaultValue;
@@ -415,16 +417,12 @@ var BaseValidator = class {
 		return this.addRule(rule, errorMessage, ruleOptions);
 	}
 	/**
-	* Define custom rule
-	*
-	* `value` is deliberately untyped: custom rules run in the rule pipeline,
-	* before a container validates its children (an object's fields are not yet
-	* validated or defaulted) and, when `firstErrorOnly` is `false` (the default
-	* is `true`), even after the type rule has failed. Typing it as the schema
-	* output would promise a shape the callback does not always receive.
+	* Validate the successful output after type rules, children and transformers.
+	* Refinements are skipped for absent/null values and failed validation.
 	*/
 	refine(callback) {
-		return this.addRule({
+		const instance = this.instance;
+		instance.refinements.push(instance.createRule({
 			name: "custom",
 			async validate(value, context) {
 				const result = await callback(value, context);
@@ -434,7 +432,30 @@ var BaseValidator = class {
 				}
 				return VALID_RULE;
 			}
-		});
+		}));
+		return instance;
+	}
+	/** Complete validation only after the entire output is available. */
+	async refineResult(result, context) {
+		if (!result.isValid || result.data == null) return result;
+		const errors = [];
+		for (const rule of this.refinements) {
+			this.setRuleAttributesList(rule);
+			const refined = await rule.validate(result.data, context);
+			if (!refined.isValid) {
+				errors.push({
+					type: rule.name,
+					error: refined.error,
+					input: refined.path ?? context.path
+				});
+				if (context.configurations?.firstErrorOnly ?? true) break;
+			}
+		}
+		return errors.length ? {
+			isValid: false,
+			errors,
+			data: void 0
+		} : result;
 	}
 	/**
 	* Add mutator to the validator
@@ -527,6 +548,16 @@ var BaseValidator = class {
 	* Validate the data
 	*/
 	async validate(data, context) {
+		const result = await this.refineResult(await this.validateRules(data, context), context);
+		if (!result.isValid && this.hasCatch) return {
+			isValid: true,
+			errors: [],
+			data: typeof this.catchValue === "function" ? await this.catchValue(result.errors, data) : this.catchValue
+		};
+		return result;
+	}
+	/** Validate presence and value rules before containers descend into children. */
+	async validateRules(data, context) {
 		if (data === null && this.isNullable) return {
 			isValid: true,
 			errors: [],
@@ -552,7 +583,7 @@ var BaseValidator = class {
 			}
 		}
 		const usedDefault = blankMatchesDefault || input == null && isUsableDefault(valueForRules) || parentFilledDefault && isUsableDefault(input);
-		const mutatedData = this.isOptional && valueForRules === void 0 ? void 0 : await this.mutate(valueForRules, context);
+		let mutatedData = this.isOptional && valueForRules === void 0 ? void 0 : await this.mutate(valueForRules, context);
 		const errors = [];
 		let isValid = true;
 		const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;
@@ -563,27 +594,26 @@ var BaseValidator = class {
 			if ((rule.requiresValue ?? true) && skipEmptyRules) continue;
 			this.setRuleAttributesList(rule);
 			const result = await rule.validate(mutatedData, context);
+			if (result.isValid && "data" in result) mutatedData = result.data;
 			if (result.isValid === false) {
 				isValid = false;
-				errors.push({
-					type: rule.name,
+				const reported = result.errors?.length ? result.errors : [{
 					error: result.error,
-					input: result.path ?? context.path
+					path: result.path
+				}];
+				for (const { error, path } of reported) errors.push({
+					type: rule.name,
+					error,
+					input: path ?? context.path
 				});
 				if (isFirstErrorOnly) break;
 			}
 		}
-		const result = {
+		return {
 			isValid,
 			errors,
 			data: mutatedData !== void 0 ? await this.startTransformationPipeline(mutatedData, context) : void 0
 		};
-		if (result.isValid === false && this.hasCatch) return {
-			isValid: true,
-			errors: [],
-			data: typeof this.catchValue === "function" ? await this.catchValue(result.errors, data) : this.catchValue
-		};
-		return result;
 	}
 	/**
 	* Set rule attributes list
@@ -642,7 +672,8 @@ var BaseValidator = class {
 			vendor: "seal",
 			types: void 0,
 			validate: async (value) => {
-				return mapToStandardResult(await validate(this, value));
+				const result = await validate(this, value);
+				return mapToStandardResult(result);
 			},
 			jsonSchema: {
 				input: (options) => this.toJsonSchema(options.target),