@shopify/react-form-state/dist/FormState.d.ts

Manage react forms tersely and type-safe with no magic.

import * as React from 'react';
import { FieldDescriptors, FieldStates, ValidationFunction } from './types';
import { List, Nested } from './components';
export interface RemoteError {
    field?: string[] | null;
    message: string;
}
declare type MaybeArray<T> = T | T[];
declare type MaybePromise<T> = T | Promise<T>;
interface SubmitHandler<Fields> {
    (formDetails: FormData<Fields>): MaybePromise<RemoteError[]> | MaybePromise<void>;
}
export declare type Validator<T, F> = MaybeArray<ValidationFunction<T, F>>;
export declare type ValidatorDictionary<FieldMap> = {
    [FieldPath in keyof FieldMap]: Validator<FieldMap[FieldPath], FieldMap>;
};
export interface FormData<Fields> {
    fields: FieldDescriptors<Fields>;
    dirty: boolean;
    valid: boolean;
    errors: RemoteError[];
}
export interface FormDetails<Fields> extends FormData<Fields> {
    submitting: boolean;
    reset(): void;
    submit(): void;
}
interface Props<Fields> {
    initialValues: Fields;
    children(form: FormDetails<Fields>): React.ReactNode;
    validators?: Partial<ValidatorDictionary<Fields>>;
    onSubmit?: SubmitHandler<Fields>;
    validateOnSubmit?: boolean;
    onInitialValuesChange?: 'reset-all' | 'reset-where-changed' | 'ignore';
    externalErrors?: RemoteError[];
}
interface State<Fields> {
    submitting: boolean;
    fields: FieldStates<Fields>;
    dirtyFields: (keyof Fields)[];
    errors: RemoteError[];
    externalErrors: RemoteError[];
}
export default class FormState<Fields extends Object> extends React.PureComponent<Props<Fields>, State<Fields>> {
    static List: typeof List;
    static Nested: typeof Nested;
    static getDerivedStateFromProps<T>(newProps: Props<T>, oldState: State<T>): {
        externalErrors: RemoteError[];
        fields: FieldStates<T>;
    } | null;
    state: State<Fields>;
    private mounted;
    private fieldsWithHandlers;
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): React.ReactNode;
    validateForm(): Promise<{}>;
    reset: () => Promise<{}>;
    private readonly formData;
    private readonly dirty;
    private readonly valid;
    private readonly hasClientErrors;
    private readonly fields;
    private submit;
    private fieldWithHandlers;
    private updateField;
    private getUpdatedDirtyFields;
    private getUpdatedField;
    private blurField;
    private validateFieldValue;
    private updateRemoteErrors;
}
export {};