svelte-hook-form/types/types.d.ts

A better version of form validation.

import type { Readable, Writable } from "svelte/store";
import type { FieldPath, FieldValues } from "./paths";
interface Resolver {
    validate(data: any): Promise<any>;
}
export declare type Fields = Record<string, any>;
export declare type FormConfig = Partial<{
    resolver: Resolver;
    validateOnChange: boolean;
}>;
export declare type SuccessCallback<T extends FieldValues> = (data: T, e: Event) => void;
export declare type ErrorCallback = (errors: Record<string, any>, e: Event) => void;
export declare type NodeElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
export declare type ValidationResult = true | string;
export declare type ValidationFunction = (...args: any[]) => ValidationResult | Promise<ValidationResult>;
export declare type Validator = string | ValidationFunction;
export declare type RuleExpression = string | Array<Validator> | Record<string, Validator> | Record<string, any>;
export declare type RegisterOption<T> = {
    defaultValue?: T;
    bail?: boolean;
    validateOnBlur?: boolean;
    validateOnMount?: boolean;
    rules?: RuleExpression;
};
export declare type FieldOption<T = any> = Partial<{
    defaultValue: T;
    rules: RuleExpression;
    validateOnMount: boolean;
    handleChange: (state: FieldState, node: Element) => void;
}>;
export interface FormControl<F extends FieldValues = FieldValues> {
    register: <T>(key: FieldPath<F>, option?: RegisterOption<T>) => Readable<FieldState>;
    unregister: (key: FieldPath<F>) => void;
    setValue: (e: Event | FieldPath<F>, value?: any) => void;
    getValue: (key: FieldPath<F>) => any;
    getValues: () => F;
    setError: (key: FieldPath<F>, errors: string[]) => void;
    setFocus: (key: FieldPath<F>, focused: boolean) => void;
    reset: (values?: Fields) => void;
    field: UseField;
    watch: (key: FieldPath<F>) => Readable<FieldState>;
}
declare type UseField = (node: HTMLElement, option?: FieldOption) => {
    update(v: FieldOption): void;
    destroy(): void;
};
export interface Form<F extends FieldValues> extends Readable<FormState>, FormControl<F> {
    control: Readable<FormControl<F>>;
    errors: Readable<Fields>;
    validate: (paths?: FieldPath<F> | Array<string>) => Promise<{
        valid: boolean;
        data: F;
    }>;
    onSubmit: (success: SuccessCallback<F>, error?: ErrorCallback) => (e: SubmitEvent) => void;
}
export declare type FormState = Readonly<{
    pending: boolean;
    dirty: boolean;
    touched: boolean;
    submitting: boolean;
    submitCount: number;
    valid: boolean;
}>;
export declare type FieldState<T = any> = Readonly<{
    defaultValue: T;
    value: T;
    pending: boolean;
    dirty: boolean;
    touched: boolean;
    valid: boolean;
    errors: string[];
}>;
export interface FieldStore extends Writable<FieldState> {
    destroy(): void;
}
export declare type ValidationRule = Readonly<{
    name: string;
    validate: <T>(value: any, params?: string[], ctx?: FormControl<T>) => Promise<ValidationResult>;
    params: any[];
}>;
export declare type ResetFormOption = {
    errors: boolean;
    dirtyFields: boolean;
};
export {};