Interface Validator

A validator is a waitable that produces a ValidationResult, indicating either validity or a problem, if all of its dependencies are loaded (or if the validator is disabled).

interface Validator {
    error: ReadonlyBinding<any>;
    force: Binding<undefined | WrappedResult<ValidationResult, any>>;
    id: string;
    isBusy: ReadonlyBinding<boolean>;
    isComplete: ReadonlyBinding<boolean>;
    isDisabled: () => boolean;
    isLocked: ReadonlyBinding<boolean>;
    isLockedWithoutValue: ReadonlyBinding<boolean>;
    isValidator: true;
    isWaitable: true;
    reset: (resetType: ResetType) => void;
    setDisabledOverride: (disabled: undefined | boolean) => void;
    setIsFinalizing: (isFinalizing: boolean) => void;
    value: ReadonlyBinding<undefined | ValidationResult>;
    wait: (options?: WaitOptions) => Promise<WaitResult>;
}

Hierarchy

Properties

error force id isBusy isComplete isDisabled isLocked isLockedWithoutValue isValidator isWaitable reset setDisabledOverride setIsFinalizing value wait

Properties

error

error: ReadonlyBinding<any>

The failure value or undefined if either incomplete or completed successfully.

force

force: Binding<undefined | WrappedResult<ValidationResult, any>>

This can be used to force the waitable to have a specified value or error -- usually for testing.

id

id: string

A technical, but human-readable ID, which isn't guaranteed to be unique

isBusy

isBusy: ReadonlyBinding<boolean>

If true, the primary function is being run / waited for

isComplete

isComplete: ReadonlyBinding<boolean>

If true, either the value or error have a defined value

isDisabled

isDisabled: () => boolean

Returns true if the validator is disabled, in which case it will always result in "validity"

isLocked

isLocked: ReadonlyBinding<boolean>

If true, this waitable is locked and the primary function won't be started

isLockedWithoutValue

isLockedWithoutValue: ReadonlyBinding<boolean>

If true, the waitable is locked and doesn't already have a value (ex. from a default value)

isValidator

isValidator: true

A marker indicating that this is a validator type

isWaitable

isWaitable: true

A marker indicating that this is a waitable type

reset

reset: (resetType: ResetType) => void

Resets the waitable so that the primary function can run again.

Type declaration

    • (resetType: ResetType): void

    • Parameters

      • resetType: ResetType

        If 'soft', current values are kept (though errors are cleared). If 'hard', both current value and errors are cleared.

      Returns void

setDisabledOverride

setDisabledOverride: (disabled: undefined | boolean) => void

Overrides the automatically-calculated disabled state of this validator, which is normally based on disabledUntil, disabledWhile, and/or disabledWhileUnmodified.

Setting a defined value overrides. Setting undefined, clears the override, going back to the calculated state.

setIsFinalizing

setIsFinalizing: (isFinalizing: boolean) => void

Sets the validator as currently finalizing or not

value

value: ReadonlyBinding<undefined | ValidationResult>

The success value or undefined if either incomplete or an error occurred.

wait

wait: (options?: WaitOptions) => Promise<WaitResult>

Returns a promise that resolves when the waitable is complete or reset or when this call times out

Settings

Member Visibility

On This Page

Properties