Class Validator<T>

StaticdefaultDelayMs

Readonlyid

ComputedasyncState

• get asyncState(): number

  The number of pending/running async jobs.

  Returns number

ComputedfirstErrorMessage

• get firstErrorMessage(): null | string

  Get the first error message (including nested objects)

  Returns null | string

ComputedinvalidKeyCount

• get invalidKeyCount(): number

  The number of invalid keys

  Returns number

ComputedinvalidKeyPathCount

• get invalidKeyPathCount(): number

  The number of invalid key paths

  Returns number

ComputedinvalidKeyPaths

• get invalidKeyPaths(): ReadonlySet<KeyPath>

  The key paths that have errors

  Keys of nested objects are included.

  Returns ReadonlySet<KeyPath>

ComputedinvalidKeys

• get invalidKeys(): ReadonlySet<KeyPath>

  The keys that have errors

  Keys of nested objects are NOT included.

  Returns ReadonlySet<KeyPath>

ComputedisValid

• get isValid(): boolean

  Whether no errors are found

  Returns boolean

ComputedisValidating

• get isValidating(): boolean

  Whether the validator is computing errors

  Returns boolean

nested

• get nested(): ReadonlyMap<KeyPath, Validator<any>>

  Nested validators

  Returns ReadonlyMap<KeyPath, Validator<any>>

ComputedreactionState

• get reactionState(): number

  The number of pending/running reactions.

  Returns number

Staticget

• get<T extends object>(target: T): Validator<T>

  Get a validator instance for the target object.

  Type Parameters

  • T extends object

  Parameters

  • target: T

  Returns Validator<T>

  Remarks

  • Returns existing instance if one exists for the target
  • Creates new instance if none exists
  • Instances are cached and garbage collected with their targets

  Throws

  TypeError if the target is not an object.

StaticgetSafe

• getSafe<T>(target: T): null | Validator<T>

  Get a validator instance for the target object.

  Same as Validator.get but returns null instead of throwing an error.

  Type Parameters

  • T

  Parameters

  • target: T

  Returns null | Validator<T>

ActionaddAsyncHandler

• addAsyncHandler<Expr>(
      expr: () => Expr,
      handler: AsyncHandler<T, NoInfer<Expr>>,
      opt?: HandlerOptions<NoInfer<Expr>>,
  ): () => void

  Add an async handler

  Type Parameters

  • Expr

  Parameters

  • expr: () => Expr

    The expression to observe
  • handler: AsyncHandler<T, NoInfer<Expr>>

    The async handler to call when the expression changes
  • Optionalopt: HandlerOptions<NoInfer<Expr>>

    The handler options

  Returns () => void

  A function to remove the handler

  Remarks

  • Handler runs immediately when added for initial validation
  • Handler is called when the watched expression changes
  • Changes are throttled by default delay
  • Provides abort signal for cancellation
  • Previous validations are aborted when new ones start

addSyncHandler

• addSyncHandler(
      handler: SyncHandler<T>,
      opt?: HandlerOptions<unknown>,
  ): () => void

  Add a sync handler

  Parameters

  • handler: SyncHandler<T>

    The sync handler containing observable expressions
  • Optionalopt: HandlerOptions<unknown>

  Returns () => void

  A function to remove the handler

  Remarks

  • Handler runs immediately when added for initial validation
  • Handler is called when observable expressions within it change
  • Changes are throttled by default delay

findErrors

• findErrors(
      searchKeyPath: KeyPath,
      prefixMatch?: boolean,
  ): Generator<[keyPath: KeyPath, error: ValidationError], void, unknown>

  Find errors for the key path

  • Can do exact or prefix matching
  • Returns all errors that match the key path
  • Includes errors from nested validators when using prefix match

  Parameters

  • searchKeyPath: KeyPath
  • prefixMatch: boolean = false

  Returns Generator<[keyPath: KeyPath, error: ValidationError], void, unknown>

getErrorMessages

• getErrorMessages(keyPath: KeyPath, prefixMatch?: boolean): Set<string>

  Get error messages for the key path

  Parameters

  • keyPath: KeyPath
  • prefixMatch: boolean = false

  Returns Set<string>

hasErrors

• hasErrors(keyPath: KeyPath, prefixMatch?: boolean): boolean

  Check if the validator has errors for the key path

  Parameters

  • keyPath: KeyPath
  • prefixMatch: boolean = false

  Returns boolean

Actionreset

• reset(): void

  Reset the validator

  Use with caution.
  Since validation is reactive, errors won't reappear until you make some changes.

  Returns void

ActionupdateErrors

• updateErrors(key: symbol, handler: InstantHandler<T>): () => void

  Update the errors immediately

  Parameters

  • key: symbol
  • handler: InstantHandler<T>

  Returns () => void

  A function to remove the errors