justus 0.1.6 → 0.2.1

package/src/index.ts

@@ -9,31 +9,37 @@ export * from './types'
 export * from './utilities'
 
 // Validators
-export { allOf, oneOf, AllOfArguments, AllOfValidator, InferAllOfValidationType, InferOneOfValidationType, OneOfArguments, OneOfValidator } from './validators/union'
 export { any, AnyValidator } from './validators/any'
-export { _array, array, arrayOf, AnyArrayValidator, ArrayConstraints, ArrayValidator } from './validators/array'
-export { _boolean, boolean, BooleanConstraints, BooleanValidator } from './validators/boolean'
+export { array, arrayOf, ArrayValidator, AnyArrayValidator } from './validators/array'
+export { boolean, BooleanValidator } from './validators/boolean'
 export { constant, ConstantValidator } from './validators/constant'
-export { _date, date, DateConstraints, DateValidator } from './validators/date'
+export { date, DateValidator } from './validators/date'
 export { never, NeverValidator } from './validators/never'
-export { _number, number, AnyNumberValidator, BrandedNumberConstraints, NumberConstraints, NumberValidator } from './validators/number'
-export { _object, object, objectOf, AnyObjectValidator, ObjectValidator } from './validators/object'
+export { AnyNumberValidator, number, NumberValidator } from './validators/number'
+export { AnyObjectValidator, object, objectOf, ObjectValidator } from './validators/object'
 export { optional, OptionalValidator } from './validators/optional'
-export { _string, string, AnyStringValidator, BrandedStringConstraints, StringConstraints, StringValidator } from './validators/string'
-export { tuple, TupleMember, TupleValidator } from './validators/tuple'
-export { _url, url, URLConstraints, URLValidator } from './validators/url'
+export { AnyStringValidator, string, StringValidator } from './validators/string'
+export { tuple, TupleValidator } from './validators/tuple'
+export { allOf, AllOfValidator, oneOf, OneOfValidator } from './validators/union'
+export { url, URLValidator } from './validators/url'
+
+// Validator Types
+export type { ArrayConstraints } from './validators/array'
+export type { BooleanConstraints } from './validators/boolean'
+export type { DateConstraints } from './validators/date'
+export type { BrandedNumberConstraints } from './validators/number'
+export type { BrandedStringConstraints, StringConstraints } from './validators/string'
+export type { TupleMember } from './validators/tuple'
+export type { URLConstraints } from './validators/url'
 
 /* ========================================================================== *
  * VALIDATE FUNCTION (our main entry point)                                   *
  * ========================================================================== */
 
-import type { InferValidation, Validation, ValidationOptions } from './types'
+import { defaultValidationOptions } from './types'
 import { getValidator } from './utilities'
 
-/** Options for `validate` */
-export type ValidateOptions = {
-  -readonly [ key in keyof ValidationOptions ]?: ValidationOptions[key] | undefined
-}
+import type { InferValidation, Validation, ValidationOptions } from './types'
 
 /**
  * Validate a _value_ using the specified `Validation`.
@@ -44,15 +50,9 @@ export type ValidateOptions = {
 export function validate<V extends Validation>(
     validation: V,
     value: any,
-    options: ValidateOptions = {},
+    options?: ValidationOptions,
 ): InferValidation<V> {
-  const opts: ValidationOptions = {
-    stripAdditionalProperties: false,
-    stripForbiddenProperties: false,
-    stripOptionalNulls: false,
-    ...options,
-  }
-
+  const opts: ValidationOptions = { ...defaultValidationOptions, ...options }
   return getValidator(validation).validate(value, opts)
 }
 
@@ -73,7 +73,7 @@ export function validate<V extends Validation>(
 export function strip<V extends Validation>(
     validation: V,
     value: any,
-    options: ValidateOptions = {},
+    options?: ValidationOptions,
 ): InferValidation<V> {
   const opts: ValidationOptions = {
     stripAdditionalProperties: true,

package/src/schema.ts

@@ -1,12 +1,12 @@
-import { any } from './validators/any'
+// import { additionalValidator } from './types'
+// eslint-disable-next-line import/no-cycle
 import { getValidator } from './utilities'
+import { any } from './validators/any'
 
-import {
-  AdditionalProperties,
-  InferValidation,
+import type {
+  AdditionalProperties, InferValidation,
   Validation,
   Validator,
-  additionalValidator,
 } from './types'
 
 /* ========================================================================== *
@@ -20,10 +20,10 @@ export function _allowAdditionalProperties(allow: false): AdditionalProperties<f
 export function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>
 
 export function _allowAdditionalProperties(options?: Validation | boolean): AdditionalProperties<Validator | false> {
-  if (options === false) return { [additionalValidator]: false }
-  if (options === true) return { [additionalValidator]: any }
+  if (options === false) return { [Symbol.justusAdditionalValidator]: false }
+  if (options === true) return { [Symbol.justusAdditionalValidator]: any }
 
-  return { [additionalValidator]: options ? getValidator(options) : any }
+  return { [Symbol.justusAdditionalValidator]: options ? getValidator(options) : any }
 }
 
 /**
@@ -38,4 +38,6 @@ export function _allowAdditionalProperties(options?: Validation | boolean): Addi
 export const allowAdditionalProperties = _allowAdditionalProperties as
   typeof _allowAdditionalProperties & AdditionalProperties<Validator<any>>
 
-allowAdditionalProperties[additionalValidator] = any
+// Remember to inject our `any` validator as the default for when
+// `allowAdditionalProperties` is _not_ used as a function
+allowAdditionalProperties[Symbol.justusAdditionalValidator] = any

package/src/types.ts

@@ -2,17 +2,23 @@
  * SYMBOLS IDENTIFYING SPECIAL FUNCTIONALITIES                                *
  * ========================================================================== */
 
-/** A symbol indicating that an instance is (in fact) a `Validator`. */
-export const isValidator = Symbol.for('justus.isValidator')
-
-/** A symbol indicating the `Validator` for a `Tuple`'s rest parameter. */
-export const restValidator = Symbol.for('justus.restValidator')
-
-/** A symbol indicating the `Validator` for a `Schema`. */
-export const schemaValidator = Symbol.for('justus.schemaValidator')
+declare global {
+  interface SymbolConstructor {
+    /** A symbol associated with a `Validator` instance. */
+    readonly justusValidator: unique symbol
+    /** A symbol indicating the `Validator` for a `Tuple`'s rest parameter. */
+    readonly justusRestValidator: unique symbol
+    /** A symbol indicating the `Validator` for a `Schema`'s additional properties. */
+    readonly justusAdditionalValidator: unique symbol
+  }
+}
 
-/** A symbol indicating the `Validator` for a `Schema`'s additional properties. */
-export const additionalValidator = Symbol.for('justus.additionalValidator')
+/* Inject our symbols as globals */
+Object.defineProperties(Symbol, {
+  justusValidator: { value: Symbol.for('justus.Validator') },
+  justusRestValidator: { value: Symbol.for('justus.restValidator') },
+  justusAdditionalValidator: { value: Symbol.for('justus.additionalValidator') },
+})
 
 /* ========================================================================== *
  * BASIC VALIDATION TYPES                                                     *
@@ -22,12 +28,21 @@ export const additionalValidator = Symbol.for('justus.additionalValidator')
  * Options to be using while validating.
  */
 export interface ValidationOptions {
-  /** Strip additional, undeclared properties from objects */
-  readonly stripAdditionalProperties: boolean,
-  /** Strip `null`s from an object when associated with an optional key */
-  readonly stripOptionalNulls: boolean,
-  /** Ignore and strip forbidden (`never`) properties from objects */
-  readonly stripForbiddenProperties: boolean,
+  /** Strip additional, undeclared properties from objects (default: `false`) */
+  stripAdditionalProperties?: boolean,
+  /** Strip `null`s from an object when associated with an optional key (default: `false`) */
+  stripOptionalNulls?: boolean,
+  /** Ignore and strip forbidden (`never`) properties from objects (default: `false`) */
+  stripForbiddenProperties?: boolean,
+}
+
+/**
+ * Default validation options.
+ */
+export const defaultValidationOptions: Readonly<Required<ValidationOptions>> = {
+  stripAdditionalProperties: false,
+  stripForbiddenProperties: false,
+  stripOptionalNulls: false,
 }
 
 /**
@@ -35,12 +50,12 @@ export interface ValidationOptions {
  * (possibly) converting it the required type `T`.
  */
 export interface Validator<T = any> extends Iterable<TupleRestParameter<T>> {
-  [isValidator]: true
+  [Symbol.justusValidator]: this
 
   optional?: boolean
 
   /** Validate a _value_ and optionally convert it to the required `Type` */
-  validate(value: unknown, options: ValidationOptions): T
+  validate(value: unknown, options?: ValidationOptions | undefined): T
 
   /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
   [Symbol.iterator](): Generator<TupleRestParameter<T>>;
@@ -60,7 +75,7 @@ export function makeValidatorFactory<
     optional: validator.optional,
     validate: validator.validate.bind(validator),
     [Symbol.iterator]: validator[Symbol.iterator].bind(validator),
-    [isValidator]: true,
+    [Symbol.justusValidator]: validator,
   }) as F & V
 }
 
@@ -68,17 +83,18 @@ export function makeValidatorFactory<
  * A `Validator` is an object capable of validating a given _value_ and
  * (possibly) converting it the required type `T`.
  */
-export abstract class AbstractValidator<T = any> implements Iterable<TupleRestParameter<T>> {
-  [isValidator]: true = true
+export abstract class AbstractValidator<T = any>
+implements Validator<T>, Iterable<TupleRestParameter<T>> {
+  [Symbol.justusValidator] = this
 
   optional?: boolean = undefined
 
   /** Validate a _value_ and optionally convert it to the required `Type` */
-  abstract validate(value: unknown, options: ValidationOptions): T
+  abstract validate(value: unknown, options?: ValidationOptions | undefined): T
 
   /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
   * [Symbol.iterator](): Generator<TupleRestParameter<T>> {
-    yield { [restValidator]: this }
+    yield { [Symbol.justusRestValidator]: this }
   }
 }
 
@@ -149,7 +165,7 @@ export type Tuple = readonly (Validation | TupleRestParameter)[]
  * ```
  */
 export type TupleRestParameter<T = any> = {
-  [restValidator] : Validator<T>
+  [Symbol.justusRestValidator] : Validator<T>
 }
 
 /**
@@ -182,7 +198,7 @@ export type InferTuple<T> =
  */
 export interface Schema {
   [ key: string ] : Validation
-  [ additionalValidator ]?: Validator | false
+  [ Symbol.justusAdditionalValidator ]?: Validator | false
 }
 
 /**
@@ -190,7 +206,7 @@ export interface Schema {
  * properties, and the `Validator` used to validate them.
  */
 export interface AdditionalProperties<V extends Validator | false> {
-  [ additionalValidator ]: V
+  [ Symbol.justusAdditionalValidator ]: V
 }
 
 /* ========================================================================== *

package/src/utilities.ts

@@ -1,7 +1,10 @@
 import { ConstantValidator, nullValidator } from './validators/constant'
-import { isValidator, Schema, schemaValidator, Validation, Validator } from './types'
-import { TupleValidator } from './validators/tuple'
+// eslint-disable-next-line import/no-cycle
 import { ObjectValidator } from './validators/object'
+// eslint-disable-next-line import/no-cycle
+import { TupleValidator } from './validators/tuple'
+
+import type { Schema, Validation, Validator } from './types'
 
 /* ========================================================================== *
  * UTILITY FUNCTIONS                                                          *
@@ -16,8 +19,10 @@ export function getValidator(validation: Validation): Validator {
   // Null is a constant
   if (validation === null) return nullValidator
 
-  // Validator instance (either object or function)
-  if ((<any> validation)[isValidator] === true) return validation as Validator
+  // Anything with a validor associated with
+  if ((<any> validation)[Symbol.justusValidator]) {
+    return (<any> validation)[Symbol.justusValidator] as Validator
+  }
 
   // Other types
   switch (typeof validation) {
@@ -29,8 +34,6 @@ export function getValidator(validation: Validation): Validator {
 
     // other objects...
     case 'object':
-      // pre-compiled schema with validator
-      if (schemaValidator in validation) return (<any> validation)[schemaValidator]
       // arrays are tuples
       if (Array.isArray(validation)) return new TupleValidator(validation)
       // any other object is a schema

package/src/validators/array.ts

@@ -1,8 +1,10 @@
 import { assertSchema, assertValidation, ValidationErrorBuilder } from '../errors'
-import { InferValidation, Validation, ValidationOptions, AbstractValidator, Validator, makeValidatorFactory } from '../types'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 import { any } from './any'
 
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+
 /* ========================================================================== *
  * ARRAYS VALIDATION                                                           *
  * ========================================================================== */
@@ -21,8 +23,7 @@ export interface ArrayConstraints<V extends Validation> {
 
 /** Basic validator for `Array` instances. */
 export class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
-  validate(value: unknown, options: ValidationOptions): T[] {
-    void options
+  validate(value: unknown): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
     return [ ...value ]
   }
@@ -55,7 +56,7 @@ export class ArrayValidator<T> extends AbstractValidator<T[]> {
     this.uniqueItems = uniqueItems
   }
 
-  validate(value: unknown, options: ValidationOptions): T[] {
+  validate(value: unknown, options?: ValidationOptions): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
 
     assertValidation(value.length >= this.minItems,
@@ -88,7 +89,7 @@ export class ArrayValidator<T> extends AbstractValidator<T[]> {
 
 /* -------------------------------------------------------------------------- */
 
-export function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
+function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
   const items = constraints.items ? getValidator(constraints.items) : any
   return new ArrayValidator({ ...constraints, items })
 }

package/src/validators/boolean.ts

@@ -1,5 +1,5 @@
-import { AbstractValidator, makeValidatorFactory } from '../types'
 import { assertValidation } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
 
 /** Constraints to validate a `boolean` with. */
 export interface BooleanConstraints {
@@ -37,7 +37,7 @@ export class BooleanValidator extends AbstractValidator<boolean> {
   }
 }
 
-export function _boolean(constraints: BooleanConstraints): BooleanValidator {
+function _boolean(constraints: BooleanConstraints): BooleanValidator {
   return new BooleanValidator(constraints)
 }
 

package/src/validators/constant.ts

@@ -1,5 +1,7 @@
-import { AbstractValidator, Validator } from '../types'
 import { assertValidation } from '../errors'
+import { AbstractValidator } from '../types'
+
+import type { Validator } from '../types'
 
 /** A `Validator` for _constants_. */
 export class ConstantValidator<T extends string | number | boolean | null> extends AbstractValidator<T> {

package/src/validators/date.ts

@@ -64,7 +64,7 @@ export class DateValidator extends AbstractValidator<Date> {
   }
 }
 
-export function _date(constraints: DateConstraints): DateValidator {
+function _date(constraints: DateConstraints): DateValidator {
   return new DateValidator(constraints)
 }
 

package/src/validators/never.ts

@@ -1,11 +1,13 @@
 import { ValidationError } from '../errors'
-import { ValidationOptions, AbstractValidator } from '../types'
+import { AbstractValidator, defaultValidationOptions } from '../types'
+
+import type { ValidationOptions } from '../types'
 
 /** A `Validator` validating _nothing_. */
 export class NeverValidator extends AbstractValidator<never> {
   optional: true = true
 
-  validate(value: unknown, options: ValidationOptions): never {
+  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): never {
     const { stripForbiddenProperties } = options
 
     // @ts-expect-error

package/src/validators/number.ts

@@ -1,6 +1,7 @@
-import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { assertSchema, assertValidation } from '../errors'
-import { ValidationError } from '..'
+import { assertSchema, assertValidation, ValidationError } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
 
 /* ========================================================================== */
 
@@ -160,10 +161,10 @@ export class NumberValidator<N extends number = number> extends AbstractValidato
 }
 
 
-export function _number(constraints: NumberConstraints): NumberValidator<number>
-export function _number<N extends number>(constraints: NumberConstraints): NumberValidator<N>
-export function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
-export function _number(constraints: NumberConstraints): Validator<number> {
+function _number(constraints: NumberConstraints): NumberValidator<number>
+function _number<N extends number>(constraints: NumberConstraints): NumberValidator<N>
+function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
+function _number(constraints: NumberConstraints): Validator<number> {
   return new NumberValidator(constraints)
 }
 

package/src/validators/object.ts

@@ -1,20 +1,17 @@
+import { assertValidation, ValidationErrorBuilder } from '../errors'
+// eslint-disable-next-line import/no-cycle
+import { allowAdditionalProperties } from '../schema'
 import {
-  InferSchema,
-  Schema,
-  TupleRestParameter,
-  ValidationOptions,
-  Validator,
   AbstractValidator,
-  additionalValidator,
-  restValidator,
-  schemaValidator,
+  defaultValidationOptions,
   makeValidatorFactory,
-  Validation,
-  InferValidation,
 } from '../types'
-import { assertValidation, ValidationErrorBuilder } from '../errors'
 import { getValidator } from '../utilities'
-import { allowAdditionalProperties } from '../schema'
+
+import type {
+  InferSchema, InferValidation, Schema, TupleRestParameter, Validation, ValidationOptions,
+  Validator,
+} from '../types'
 
 /* ========================================================================== *
  * OBJECT VALIDATOR                                                           *
@@ -38,9 +35,9 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
 
   constructor(schema: S) {
     super()
-    const { [additionalValidator]: additional, ...properties } = schema
+    const { [Symbol.justusAdditionalValidator]: additional, ...properties } = schema
 
-    if (additional) this.additionalProperties = getValidator(additional)
+    if (additional) this.additionalProperties = additional
 
     for (const key of Object.keys(properties)) {
       this.validators.set(key, getValidator(properties[key]))
@@ -49,7 +46,7 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
     this.schema = schema
   }
 
-  validate(value: unknown, options: ValidationOptions): InferSchema<S> {
+  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): InferSchema<S> {
     assertValidation(typeof value === 'object', 'Value is not an "object"')
     assertValidation(value !== null, 'Value is "null"')
 
@@ -120,16 +117,16 @@ export class ObjectValidator<S extends Schema> extends AbstractValidator<InferSc
   }
 }
 
-export function _object<S extends Schema>(schema: S): S & {
+function _object<S extends Schema>(schema: S): S & {
   [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>
 } {
   const validator = new ObjectValidator(schema)
   function* iterator(): Generator<TupleRestParameter> {
-    yield { [restValidator]: validator }
+    yield { [Symbol.justusRestValidator]: validator }
   }
 
   return Object.defineProperties(schema, {
-    [schemaValidator]: { value: validator, enumerable: false },
+    [Symbol.justusValidator]: { value: validator, enumerable: false },
     [Symbol.iterator]: { value: iterator, enumerable: false },
   }) as any
 }

package/src/validators/optional.ts

@@ -1,6 +1,8 @@
-import { AbstractValidator, InferValidation, Validation, ValidationOptions, Validator } from '../types'
+import { AbstractValidator, defaultValidationOptions } from '../types'
 import { getValidator } from '../utilities'
 
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+
 /**
  * A `Validator` for _optional_ properties (that is `type | undefined`).
  */
@@ -24,17 +26,13 @@ export class OptionalValidator<
     }
 
     try {
-      this.defaultValue = validator.validate(defaultValue, {
-        stripAdditionalProperties: false,
-        stripForbiddenProperties: false,
-        stripOptionalNulls: false,
-      })
+      this.defaultValue = validator.validate(defaultValue, defaultValidationOptions)
     } catch (cause) {
       throw new TypeError('Default value does not match validator', { cause })
     }
   }
 
-  validate(value: unknown, options: ValidationOptions): D extends undefined ? T | undefined : T {
+  validate(value: unknown, options?: ValidationOptions): D extends undefined ? T | undefined : T {
     if (value === undefined) return this.defaultValue as any // do not validate defaults!
     return this.validator.validate(value, options)
   }

package/src/validators/string.ts

@@ -1,5 +1,7 @@
-import { Branding, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { assertValidation, assertSchema } from '../errors'
+import { assertSchema, assertValidation } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
 
 /** Constraints to validate a `string` with. */
 export interface StringConstraints {
@@ -68,10 +70,10 @@ export class StringValidator<S extends string = string> extends AbstractValidato
   }
 }
 
-export function _string(constraints: StringConstraints): StringValidator<string>
-export function _string<S extends string>(constraints: StringConstraints): StringValidator<S>
-export function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
-export function _string(constraints: StringConstraints): Validator<string> {
+function _string(constraints: StringConstraints): StringValidator<string>
+function _string<S extends string>(constraints: StringConstraints): StringValidator<S>
+function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>
+function _string(constraints: StringConstraints): Validator<string> {
   return new StringValidator(constraints)
 }
 

package/src/validators/tuple.ts

@@ -1,9 +1,11 @@
-import { Tuple, InferTuple, Validator, AbstractValidator, restValidator } from '../types'
-import { ValidationOptions } from '../types'
 import { assertValidation, ValidationError } from '../errors'
+import { AbstractValidator } from '../types'
+// eslint-disable-next-line import/no-cycle
 import { getValidator } from '../utilities'
 import { nullValidator } from './constant'
 
+import type { InferTuple, Tuple, ValidationOptions, Validator } from '../types'
+
 export interface TupleMember { single: boolean, validator: Validator }
 
 /** A `Validator` for _tuples_. */
@@ -18,8 +20,8 @@ export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTupl
     for (const item of tuple) {
       if (item === null) { // god knows why typeof null === "object"
         members.push({ single: true, validator: nullValidator })
-      } else if ((typeof item === 'object') && (restValidator in item)) {
-        members.push({ single: false, validator: (<any>item)[restValidator] })
+      } else if ((typeof item === 'object') && (Symbol.justusRestValidator in item)) {
+        members.push({ single: false, validator: (<any>item)[Symbol.justusRestValidator] })
       } else {
         members.push({ single: true, validator: getValidator(item) })
       }
@@ -29,7 +31,7 @@ export class TupleValidator<T extends Tuple> extends AbstractValidator<InferTupl
     this.tuple = tuple
   }
 
-  validate(value: unknown, options: ValidationOptions): InferTuple<T> {
+  validate(value: unknown, options?: ValidationOptions): InferTuple<T> {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
 
     // Empty tuples

package/src/validators/union.ts

@@ -1,11 +1,13 @@
 import { assertSchema, ValidationErrorBuilder } from '../errors'
-import {
-  AbstractValidator, InferValidation,
+import { AbstractValidator } from '../types'
+import { getValidator } from '../utilities'
+
+import type {
+  InferValidation,
   Validation,
   ValidationOptions,
   Validator,
 } from '../types'
-import { getValidator } from '../utilities'
 
 /* -------------------------------------------------------------------------- */
 
@@ -34,7 +36,7 @@ export class OneOfValidator<A extends OneOfArguments> extends AbstractValidator<
     assertSchema(this.validators.length > 0, 'At least one validation required in "oneOf"')
   }
 
-  validate(value: unknown, options: ValidationOptions): InferOneOfValidationType<A> {
+  validate(value: unknown, options?: ValidationOptions): InferOneOfValidationType<A> {
     const builder = new ValidationErrorBuilder()
     for (const validator of this.validators) {
       try {
@@ -75,7 +77,7 @@ export class AllOfValidator<A extends AllOfArguments> extends AbstractValidator<
     assertSchema(this.validators.length > 0, 'At least one validation required in "allOf"')
   }
 
-  validate(value: unknown, options: ValidationOptions): InferAllOfValidationType<A> {
+  validate(value: unknown, options?: ValidationOptions): InferAllOfValidationType<A> {
     for (const validator of this.validators) {
       value = validator.validate(value, options)
     }

package/src/validators/url.ts

@@ -1,7 +1,10 @@
-import { ConstantValidator } from './constant'
 import { ValidationError, ValidationErrorBuilder } from '../errors'
-import { Schema, Validator, AbstractValidator, makeValidatorFactory } from '../types'
-import { ObjectValidator, ValidationOptions } from '..'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+import { ConstantValidator } from './constant'
+import { ObjectValidator } from './object'
+
+import type { ValidationOptions } from '..'
+import type { Schema, Validator } from '../types'
 
 const KEYS: Exclude<keyof URLConstraints, 'searchParams'>[] = [
   'href',
@@ -127,11 +130,9 @@ export class URLValidator extends AbstractValidator<URL> {
   }
 }
 
-const anyURLValidator = new URLValidator()
-
-export function _url(constraints: URLConstraints): URLValidator {
+function _url(constraints: URLConstraints): URLValidator {
   return new URLValidator(constraints)
 }
 
 /** Validate URLs and convert them to `URL` instances. */
-export const url = makeValidatorFactory(anyURLValidator, _url)
+export const url = makeValidatorFactory(new URLValidator(), _url)