Class Validator<T>

StaticdefaultDelayMs

Readonlyid

ComputedasyncState

• get asyncState(): number

  The number of pending/running async jobs.

  Returns number

ComputedfirstErrorMessage

• get firstErrorMessage(): string | null

  Get the first error message (including nested objects)

  Returns string | null

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 (including nested validators)

  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 the target only if everything their handlers observe is too

  Throws

  TypeError if the target is not an object.

StaticgetSafe

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

  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 Validator<T> | null

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
  • Changes made while the handler is running are queued, not aborted: the latest value is validated after the running handler settles
  • Provides abort signal, which is aborted when the validator is reset or the handler is removed; the result of an aborted run is discarded, so the errors it collected are not applied

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, any>

  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, any>

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.
  Running async validations are aborted, and their results are discarded.

  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