@fgv/ts-utils 5.0.0-17 → 5.0.0-19

package/dist/ts-utils.d.ts

@@ -58,10 +58,11 @@ declare class ArrayValidator<T, TC = unknown> extends ValidatorBase<T[], TC> {
      * validator.
      * @param from - The `unknown` value to be tested.
      * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
      * @returns Returns `true` if `from` is an `array` of valid elements, or
      * {@link Failure} with an error message if not.
      */
-    protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T[], TC>): boolean | Failure<T[]>;
 }
 
 /**
@@ -74,7 +75,6 @@ declare interface ArrayValidatorConstructorParams<T, TC = unknown> extends Valid
 
 declare namespace Base {
     export {
-        ValidatorFunc,
         GenericValidatorConstructorParams,
         GenericValidator
     }
@@ -3420,7 +3420,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                         * {@inheritdoc Validation.ValidatorBase._validate}
                                         * @internal
                                         */
-                                       protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+                                       protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
                                    }
 
                                    /**
@@ -3522,10 +3522,11 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                         * of the configured validators.
                                         * @param from - The `unknown` value to be tested.
                                         * @param context - Optional validation context will be propagated to element validator.
+                                        * @param self - Optional self-reference for recursive validation.
                                         * @returns Returns `true` if `from` is an `array` of valid elements, or
                                         * {@link Failure} with an error message if not.
                                         */
-                                       protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
+                                       protected _validate<T>(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
                                    }
 
                                    /**
@@ -4439,11 +4440,12 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                                     * type guard, returning a `Failure<T>` containing more information about a failure.
                                                     * @param from - Value to be converted.
                                                     * @param context - Optional validation context.
+                                                    * @param self - Optional self-reference for recursive validation.
                                                     * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
                                                     * with an error message if `from` is invalid.
                                                     * @internal
                                                     */
-                                                   protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+                                                   protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
                                                }
 
                                                /**
@@ -4601,12 +4603,12 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                                                Classes,
                                                                Validators,
                                                                TypeGuardWithContext,
-                                                               ValidatorFunc,
                                                                FunctionConstraintTrait,
                                                                ConstraintTrait,
                                                                ValidatorTraitValues,
                                                                defaultValidatorTraits,
                                                                ValidatorTraits,
+                                                               ValidatorFunc,
                                                                ValidatorOptions,
                                                                Constraint,
                                                                ValidationErrorFormatter,
@@ -4722,11 +4724,12 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                                                   * Abstract validation method to me implemented by derived classes.
                                                                   * @param from - Value to be converted.
                                                                   * @param context - Optional validation context.
+                                                                  * @param self - Optional self-reference for recursive validation.
                                                                   * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
                                                                   * with an error message if `from` is invalid.
                                                                   * @internal
                                                                   */
-                                                                 protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+                                                                 protected abstract _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
                                                              }
 
                                                              /**
@@ -4740,7 +4743,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                                               * an optionally-supplied validation context of type `<TC>`.
                                                               * @public
                                                               */
-                                                             declare type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;
+                                                             declare type ValidatorFunc<T, TC> = (from: unknown, context?: TC, self?: Validator<T, TC>) => boolean | Failure<T>;
 
                                                              /**
                                                               * Options that apply to any {@link Validation.Validator | Validator}.

package/lib/packlets/validation/array.d.ts

@@ -32,9 +32,10 @@ export declare class ArrayValidator<T, TC = unknown> extends ValidatorBase<T[],
      * validator.
      * @param from - The `unknown` value to be tested.
      * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
      * @returns Returns `true` if `from` is an `array` of valid elements, or
      * {@link Failure} with an error message if not.
      */
-    protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T[], TC>): boolean | Failure<T[]>;
 }
 //# sourceMappingURL=array.d.ts.map

package/lib/packlets/validation/array.js

@@ -47,10 +47,11 @@ class ArrayValidator extends validatorBase_1.ValidatorBase {
      * validator.
      * @param from - The `unknown` value to be tested.
      * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
      * @returns Returns `true` if `from` is an `array` of valid elements, or
      * {@link Failure} with an error message if not.
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         if (Array.isArray(from)) {
             for (const elem of from) {
                 const result = this._validateElement.validate(elem, context);

package/lib/packlets/validation/common.d.ts

@@ -1,15 +1,7 @@
-import { Failure } from '../base';
 /**
  * A type guard function which validates a specific type, with an optional context
  * that can be used to shape the validation.
  * @public
  */
 export type TypeGuardWithContext<T, TC = unknown> = (from: unknown, context?: TC) => from is T;
-/**
- * Type for a validation function, which validates that a supplied `unknown`
- * value is a valid value of type `<T>`, possibly as influenced by
- * an optionally-supplied validation context of type `<TC>`.
- * @public
- */
-export type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;
 //# sourceMappingURL=common.d.ts.map

package/lib/packlets/validation/field.d.ts

@@ -38,6 +38,6 @@ export declare class FieldValidator<T, TC = unknown> extends ValidatorBase<T, TC
     /**
      * {@inheritdoc Validation.ValidatorBase._validate}
      */
-    protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=field.d.ts.map

package/lib/packlets/validation/field.js

@@ -48,7 +48,7 @@ class FieldValidator extends validatorBase_1.ValidatorBase {
     /**
      * {@inheritdoc Validation.ValidatorBase._validate}
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         if (typeof from === 'object' && !Array.isArray(from) && from !== null) {
             const optional = this._fieldOptions.optional === true;
             if ((0, base_1.isKeyOf)(this.fieldName, from)) {

package/lib/packlets/validation/genericValidator.d.ts

@@ -1,11 +1,6 @@
 import { Brand, Result } from '../base';
 import { ConstraintTrait, ValidatorTraits } from './traits';
-import { Constraint, ValidationErrorFormatter, Validator, ValidatorOptions } from './validator';
-import { ValidatorFunc } from './common';
-/**
- * @deprecated Use {@link Validation.Common.ValidatorFunc | Validation.Common.ValidatorFunc} instead.
- */
-export { ValidatorFunc };
+import { Constraint, ValidationErrorFormatter, Validator, ValidatorFunc, ValidatorOptions } from './validator';
 /**
  * Options used to initialize a {@link Validation.Base.GenericValidator | GenericValidator}.
  * @public

package/lib/packlets/validation/genericValidator.js

@@ -59,7 +59,7 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.validate}
      */
     validate(from, context) {
-        const result = this._validator(from, this._context(context));
+        const result = this._validator(from, this._context(context), this);
         if (typeof result === 'boolean') {
             return result ? (0, base_1.succeed)(from) : (0, base_1.fail)('Invalid value');
         }
@@ -69,7 +69,7 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.convert}
      */
     convert(from, context) {
-        const result = this._validator(from, this._context(context));
+        const result = this._validator(from, this._context(context), this);
         if (typeof result === 'boolean') {
             return result ? (0, base_1.succeed)(from) : (0, base_1.fail)('Invalid value');
         }
@@ -85,15 +85,15 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.guard}
      */
     guard(from, context) {
-        return this._validator(from, this._context(context)) === true;
+        return this._validator(from, this._context(context), this) === true;
     }
     /**
      * {@inheritdoc Validation.Validator.optional}
      */
     optional() {
         return new GenericValidator({
-            validator: (from, context) => {
-                return from === undefined || this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                return from === undefined || this._validator(from, this._context(context), this);
             },
             traits: { isOptional: true }
         });
@@ -104,8 +104,8 @@ class GenericValidator {
     withConstraint(constraint, trait) {
         trait = trait !== null && trait !== void 0 ? trait : { type: 'function' };
         return new GenericValidator({
-            validator: (from, context) => {
-                const result = this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
                 if (result === true) {
                     const constraintResult = constraint(from);
                     if (typeof constraintResult === 'boolean') {
@@ -128,8 +128,8 @@ class GenericValidator {
             throw new Error(`Cannot replace existing brand "${this.brand}" with "${brand}".`);
         }
         return new GenericValidator({
-            validator: (from, context) => {
-                return this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                return this._validator(from, this._context(context), this);
             },
             traits: { brand }
         });
@@ -139,8 +139,8 @@ class GenericValidator {
      */
     withFormattedError(formatter) {
         return new GenericValidator({
-            validator: (from, context) => {
-                const result = this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
                 if (result === true) {
                     return true;
                 }

package/lib/packlets/validation/object.d.ts

@@ -110,6 +110,6 @@ export declare class ObjectValidator<T, TC = unknown> extends ValidatorBase<T, T
      * {@inheritdoc Validation.ValidatorBase._validate}
      * @internal
      */
-    protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=object.d.ts.map

package/lib/packlets/validation/object.js

@@ -109,7 +109,7 @@ class ObjectValidator extends validatorBase_1.ValidatorBase {
      * {@inheritdoc Validation.ValidatorBase._validate}
      * @internal
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         if (typeof from !== 'object' || from === null || Array.isArray(from)) {
             return (0, base_1.fail)('source is not an object');
         }

package/lib/packlets/validation/oneOf.d.ts

@@ -31,9 +31,10 @@ export declare class OneOfValidator<T, TC = unknown> extends ValidatorBase<T, TC
      * of the configured validators.
      * @param from - The `unknown` value to be tested.
      * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
      * @returns Returns `true` if `from` is an `array` of valid elements, or
      * {@link Failure} with an error message if not.
      */
-    protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate<T>(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=oneOf.d.ts.map

package/lib/packlets/validation/oneOf.js

@@ -46,10 +46,11 @@ class OneOfValidator extends validatorBase_1.ValidatorBase {
      * of the configured validators.
      * @param from - The `unknown` value to be tested.
      * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
      * @returns Returns `true` if `from` is an `array` of valid elements, or
      * {@link Failure} with an error message if not.
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         const found = this._validators.some((v) => v.validate(from).success);
         if (found) {
             return true;

package/lib/packlets/validation/typeGuard.d.ts

@@ -1,7 +1,7 @@
 import { Failure } from '../base';
 import { ValidatorBase, ValidatorBaseConstructorParams } from './validatorBase';
 import { TypeGuardWithContext } from './common';
-import { ValidatorOptions } from './validator';
+import { Validator, ValidatorOptions } from './validator';
 /**
  * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
  * @public
@@ -34,10 +34,11 @@ export declare class TypeGuardValidator<T, TC = unknown> extends ValidatorBase<T
      * type guard, returning a `Failure<T>` containing more information about a failure.
      * @param from - Value to be converted.
      * @param context - Optional validation context.
+     * @param self - Optional self-reference for recursive validation.
      * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
      * with an error message if `from` is invalid.
      * @internal
      */
-    protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=typeGuard.d.ts.map

package/lib/packlets/validation/typeGuard.js

@@ -47,11 +47,12 @@ class TypeGuardValidator extends validatorBase_1.ValidatorBase {
      * type guard, returning a `Failure<T>` containing more information about a failure.
      * @param from - Value to be converted.
      * @param context - Optional validation context.
+     * @param self - Optional self-reference for recursive validation.
      * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
      * with an error message if `from` is invalid.
      * @internal
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         if (this._guard(from, context)) {
             return true;
         }

package/lib/packlets/validation/validator.d.ts

@@ -1,5 +1,12 @@
 import { Brand, Failure, Result } from '../base';
 import { ConstraintTrait, ValidatorTraits } from './traits';
+/**
+ * Type for a validation function, which validates that a supplied `unknown`
+ * value is a valid value of type `<T>`, possibly as influenced by
+ * an optionally-supplied validation context of type `<TC>`.
+ * @public
+ */
+export type ValidatorFunc<T, TC> = (from: unknown, context?: TC, self?: Validator<T, TC>) => boolean | Failure<T>;
 /**
  * Options that apply to any {@link Validation.Validator | Validator}.
  * @public

package/lib/packlets/validation/validatorBase.d.ts

@@ -19,10 +19,11 @@ export declare abstract class ValidatorBase<T, TC = unknown> extends GenericVali
      * Abstract validation method to me implemented by derived classes.
      * @param from - Value to be converted.
      * @param context - Optional validation context.
+     * @param self - Optional self-reference for recursive validation.
      * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
      * with an error message if `from` is invalid.
      * @internal
      */
-    protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected abstract _validate(from: unknown, context?: TC, self?: import('./validator').Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=validatorBase.d.ts.map

package/lib/packlets/validation/validatorBase.js

@@ -34,7 +34,7 @@ class ValidatorBase extends genericValidator_1.GenericValidator {
      * @internal
      */
     constructor(params) {
-        super(Object.assign({ validator: (from, context) => this._validate(from, context) }, params));
+        super(Object.assign({ validator: (from, context, self) => this._validate(from, context, self) }, params));
     }
 }
 exports.ValidatorBase = ValidatorBase;

package/lib/packlets/validation/validators.d.ts

@@ -1,9 +1,9 @@
 import { ArrayValidator, ArrayValidatorConstructorParams } from './array';
 import { FieldValidators, ObjectValidator, ObjectValidatorConstructorParams } from './object';
 import { TypeGuardValidator, TypeGuardValidatorConstructorParams } from './typeGuard';
-import { TypeGuardWithContext, ValidatorFunc } from './common';
+import { TypeGuardWithContext } from './common';
 import { OneOfValidator, OneOfValidatorConstructorParams } from './oneOf';
-import { Validator } from './validator';
+import { Validator, ValidatorFunc } from './validator';
 /**
  * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
  * @public

package/lib/packlets/validation/validators.js

@@ -94,7 +94,7 @@ function arrayOf(validateElement, params) {
 function recordOf(validator, options) {
     const opts = Object.assign({ onError: 'fail' }, options);
     return new genericValidator_1.GenericValidator({
-        validator: (from, context) => {
+        validator: (from, context, self) => {
             if (typeof from !== 'object' || from === null || Array.isArray(from)) {
                 return (0, base_1.fail)(`Not a string-keyed object: ${JSON.stringify(from)}`);
             }
@@ -139,7 +139,7 @@ function recordOf(validator, options) {
  */
 function enumeratedValue(values) {
     return new genericValidator_1.GenericValidator({
-        validator: (from, context) => {
+        validator: (from, context, self) => {
             if (typeof from === 'string') {
                 const v = context !== null && context !== void 0 ? context : values;
                 const index = v.indexOf(from);
@@ -156,7 +156,7 @@ function enumeratedValue(values) {
  */
 function literal(value) {
     return new genericValidator_1.GenericValidator({
-        validator: (from) => {
+        validator: (from, context, self) => {
             return from === value
                 ? true
                 : (0, base_1.fail)(`Expected literal ${String(value)}, found "${JSON.stringify(from, undefined, 2)}`);

package/lib/test/unit/validation/recursiveValidation.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=recursiveValidation.test.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-utils",
-  "version": "5.0.0-17",
+  "version": "5.0.0-19",
   "description": "Assorted Typescript Utilities",
   "main": "lib/index.js",
   "types": "dist/ts-utils.d.ts",

package/src/packlets/validation/array.ts

@@ -65,10 +65,11 @@ export class ArrayValidator<T, TC = unknown> extends ValidatorBase<T[], TC> {
    * validator.
    * @param from - The `unknown` value to be tested.
    * @param context - Optional validation context will be propagated to element validator.
+   * @param self - Optional self-reference for recursive validation.
    * @returns Returns `true` if `from` is an `array` of valid elements, or
    * {@link Failure} with an error message if not.
    */
-  protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T> {
+  protected _validate(from: unknown, context?: TC, self?: Validator<T[], TC>): boolean | Failure<T[]> {
     if (Array.isArray(from)) {
       for (const elem of from) {
         const result = this._validateElement.validate(elem, context);
@@ -78,6 +79,6 @@ export class ArrayValidator<T, TC = unknown> extends ValidatorBase<T[], TC> {
       }
       return true;
     }
-    return fail<T>(`"${from}": not an array`);
+    return fail<T[]>(`"${from}": not an array`);
   }
 }

package/src/packlets/validation/common.ts

@@ -20,19 +20,9 @@
  * SOFTWARE.
  */
 
-import { Failure } from '../base';
-
 /**
  * A type guard function which validates a specific type, with an optional context
  * that can be used to shape the validation.
  * @public
  */
 export type TypeGuardWithContext<T, TC = unknown> = (from: unknown, context?: TC) => from is T;
-
-/**
- * Type for a validation function, which validates that a supplied `unknown`
- * value is a valid value of type `<T>`, possibly as influenced by
- * an optionally-supplied validation context of type `<TC>`.
- * @public
- */
-export type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;

package/src/packlets/validation/field.ts

@@ -75,7 +75,7 @@ export class FieldValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
   /**
    * {@inheritdoc Validation.ValidatorBase._validate}
    */
-  protected _validate(from: unknown, context?: TC): boolean | Failure<T> {
+  protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T> {
     if (typeof from === 'object' && !Array.isArray(from) && from !== null) {
       const optional = this._fieldOptions.optional === true;
 

package/src/packlets/validation/genericValidator.ts

@@ -22,14 +22,13 @@
 
 import { Brand, Failure, Result, fail, succeed } from '../base';
 import { ConstraintTrait, ValidatorTraits } from './traits';
-import { Constraint, ValidationErrorFormatter, Validator, ValidatorOptions } from './validator';
-
-import { ValidatorFunc } from './common';
-
-/**
- * @deprecated Use {@link Validation.Common.ValidatorFunc | Validation.Common.ValidatorFunc} instead.
- */
-export { ValidatorFunc };
+import {
+  Constraint,
+  ValidationErrorFormatter,
+  Validator,
+  ValidatorFunc,
+  ValidatorOptions
+} from './validator';
 
 /**
  * Options used to initialize a {@link Validation.Base.GenericValidator | GenericValidator}.
@@ -93,7 +92,7 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
    * {@inheritdoc Validation.Validator.validate}
    */
   public validate(from: unknown, context?: TC): Result<T> {
-    const result = this._validator(from, this._context(context));
+    const result = this._validator(from, this._context(context), this);
     if (typeof result === 'boolean') {
       return result ? succeed(from as T) : fail<T>('Invalid value');
     }
@@ -104,7 +103,7 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
    * {@inheritdoc Validation.Validator.convert}
    */
   public convert(from: unknown, context?: TC): Result<T> {
-    const result = this._validator(from, this._context(context));
+    const result = this._validator(from, this._context(context), this);
     if (typeof result === 'boolean') {
       return result ? succeed(from as T) : fail<T>('Invalid value');
     }
@@ -122,7 +121,7 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
    * {@inheritdoc Validation.Validator.guard}
    */
   public guard(from: unknown, context?: TC): from is T {
-    return this._validator(from, this._context(context)) === true;
+    return this._validator(from, this._context(context), this) === true;
   }
 
   /**
@@ -130,8 +129,8 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
    */
   public optional(): Validator<T | undefined, TC> {
     return new GenericValidator({
-      validator: (from: unknown, context?: TC) => {
-        return from === undefined || this._validator(from, this._context(context));
+      validator: (from: unknown, context?: TC, self?: Validator<T | undefined, TC>) => {
+        return from === undefined || this._validator(from, this._context(context), this);
       },
       traits: { isOptional: true }
     });
@@ -143,8 +142,8 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
   public withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC> {
     trait = trait ?? { type: 'function' };
     return new GenericValidator({
-      validator: (from: unknown, context?: TC): boolean | Failure<T> => {
-        const result = this._validator(from, this._context(context));
+      validator: (from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T> => {
+        const result = this._validator(from, this._context(context), this);
         if (result === true) {
           const constraintResult = constraint(from as T);
           if (typeof constraintResult === 'boolean') {
@@ -169,8 +168,8 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
     }
 
     return new GenericValidator<Brand<T, B>, TC>({
-      validator: (from: unknown, context?: TC) => {
-        return this._validator(from, this._context(context)) as boolean | Failure<Brand<T, B>>;
+      validator: (from: unknown, context?: TC, self?: Validator<Brand<T, B>, TC>) => {
+        return this._validator(from, this._context(context), this) as boolean | Failure<Brand<T, B>>;
       },
       traits: { brand }
     });
@@ -181,8 +180,8 @@ export class GenericValidator<T, TC = unknown> implements Validator<T, TC> {
    */
   public withFormattedError(formatter: ValidationErrorFormatter<TC>): Validator<T, TC> {
     return new GenericValidator<T, TC>({
-      validator: (from: unknown, context?: TC) => {
-        const result = this._validator(from, this._context(context));
+      validator: (from: unknown, context?: TC, self?: Validator<T, TC>) => {
+        const result = this._validator(from, this._context(context), this);
         if (result === true) {
           return true;
         }

package/src/packlets/validation/object.ts

@@ -179,7 +179,7 @@ export class ObjectValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
    * {@inheritdoc Validation.ValidatorBase._validate}
    * @internal
    */
-  protected _validate(from: unknown, context?: TC): boolean | Failure<T> {
+  protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T> {
     if (typeof from !== 'object' || from === null || Array.isArray(from)) {
       return fail('source is not an object');
     }

package/src/packlets/validation/oneOf.ts

@@ -64,10 +64,11 @@ export class OneOfValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
    * of the configured validators.
    * @param from - The `unknown` value to be tested.
    * @param context - Optional validation context will be propagated to element validator.
+   * @param self - Optional self-reference for recursive validation.
    * @returns Returns `true` if `from` is an `array` of valid elements, or
    * {@link Failure} with an error message if not.
    */
-  protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T> {
+  protected _validate<T>(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T> {
     const found = this._validators.some((v) => v.validate(from).success);
     if (found) {
       return true;

package/src/packlets/validation/typeGuard.ts

@@ -24,7 +24,7 @@ import { Failure, fail } from '../base';
 import { ValidatorBase, ValidatorBaseConstructorParams } from './validatorBase';
 
 import { TypeGuardWithContext } from './common';
-import { ValidatorOptions } from './validator';
+import { Validator, ValidatorOptions } from './validator';
 
 /**
  * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
@@ -69,11 +69,12 @@ export class TypeGuardValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
    * type guard, returning a `Failure<T>` containing more information about a failure.
    * @param from - Value to be converted.
    * @param context - Optional validation context.
+   * @param self - Optional self-reference for recursive validation.
    * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
    * with an error message if `from` is invalid.
    * @internal
    */
-  protected _validate(from: unknown, context?: TC): boolean | Failure<T> {
+  protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T> {
     if (this._guard(from, context)) {
       return true;
     }

package/src/packlets/validation/validator.ts

@@ -23,6 +23,18 @@
 import { Brand, Failure, Result } from '../base';
 import { ConstraintTrait, ValidatorTraits } from './traits';
 
+/**
+ * Type for a validation function, which validates that a supplied `unknown`
+ * value is a valid value of type `<T>`, possibly as influenced by
+ * an optionally-supplied validation context of type `<TC>`.
+ * @public
+ */
+export type ValidatorFunc<T, TC> = (
+  from: unknown,
+  context?: TC,
+  self?: Validator<T, TC>
+) => boolean | Failure<T>;
+
 /**
  * Options that apply to any {@link Validation.Validator | Validator}.
  * @public

package/src/packlets/validation/validatorBase.ts

@@ -44,7 +44,7 @@ export abstract class ValidatorBase<T, TC = unknown> extends GenericValidator<T,
    */
   protected constructor(params: Partial<ValidatorBaseConstructorParams<T, TC>>) {
     super({
-      validator: (from, context) => this._validate(from, context),
+      validator: (from, context, self) => this._validate(from, context, self),
       ...params
     });
   }
@@ -53,9 +53,14 @@ export abstract class ValidatorBase<T, TC = unknown> extends GenericValidator<T,
    * Abstract validation method to me implemented by derived classes.
    * @param from - Value to be converted.
    * @param context - Optional validation context.
+   * @param self - Optional self-reference for recursive validation.
    * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
    * with an error message if `from` is invalid.
    * @internal
    */
-  protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+  protected abstract _validate(
+    from: unknown,
+    context?: TC,
+    self?: import('./validator').Validator<T, TC>
+  ): boolean | Failure<T>;
 }

package/src/packlets/validation/validators.ts

@@ -26,12 +26,12 @@ import { FieldValidators, ObjectValidator, ObjectValidatorConstructorParams } fr
 import { TypeGuardValidator, TypeGuardValidatorConstructorParams } from './typeGuard';
 
 import { BooleanValidator } from './boolean';
-import { TypeGuardWithContext, ValidatorFunc } from './common';
+import { TypeGuardWithContext } from './common';
 import { GenericValidator } from './genericValidator';
 import { NumberValidator } from './number';
 import { OneOfValidator, OneOfValidatorConstructorParams } from './oneOf';
 import { StringValidator } from './string';
-import { Validator } from './validator';
+import { Validator, ValidatorFunc } from './validator';
 
 /**
  * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
@@ -121,7 +121,11 @@ export function recordOf<T, TC = unknown, TK extends string = string>(
   const opts: IRecordOfValidatorOptions<TK, TC> = { onError: 'fail', ...options };
 
   return new GenericValidator({
-    validator: (from: unknown, context?: TC): boolean | Failure<Record<TK, T>> => {
+    validator: (
+      from: unknown,
+      context?: TC,
+      self?: Validator<Record<TK, T>, TC>
+    ): boolean | Failure<Record<TK, T>> => {
       if (typeof from !== 'object' || from === null || Array.isArray(from)) {
         return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);
       }
@@ -171,7 +175,11 @@ export function recordOf<T, TC = unknown, TK extends string = string>(
  */
 export function enumeratedValue<T extends string>(values: ReadonlyArray<T>): Validator<T, ReadonlyArray<T>> {
   return new GenericValidator({
-    validator: (from: unknown, context?: ReadonlyArray<T>): boolean | Failure<T> => {
+    validator: (
+      from: unknown,
+      context?: ReadonlyArray<T>,
+      self?: Validator<T, ReadonlyArray<T>>
+    ): boolean | Failure<T> => {
       if (typeof from === 'string') {
         const v = context ?? values;
         const index = v.indexOf(from as T);
@@ -191,7 +199,7 @@ export function literal<T extends string | number | boolean | symbol | null | un
   value: T
 ): Validator<T> {
   return new GenericValidator({
-    validator: (from: unknown): boolean | Failure<T> => {
+    validator: (from: unknown, context?: unknown, self?: Validator<T>): boolean | Failure<T> => {
       return from === value
         ? true
         : fail(`Expected literal ${String(value)}, found "${JSON.stringify(from, undefined, 2)}`);