@ordojs/forms/dist/types.d.ts

Comprehensive form handling system for OrdoJS

/**
 * Core types and interfaces for the forms system
 */
export type FieldValue = string | number | boolean | Date | File | null | undefined;
export type FieldValues = Record<string, FieldValue>;
export interface FieldError {
    type: string;
    message: string;
    field?: string;
}
export interface FieldState {
    value: FieldValue;
    error: FieldError | null;
    touched: boolean;
    dirty: boolean;
    valid: boolean;
    validating: boolean;
    focused: boolean;
}
export interface FormState {
    values: FieldValues;
    errors: Record<string, FieldError>;
    touched: Record<string, boolean>;
    dirty: Record<string, boolean>;
    valid: boolean;
    validating: boolean;
    submitting: boolean;
    submitted: boolean;
    submitCount: number;
}
export interface ValidationRule {
    type: string;
    message: string;
    validate: (value: FieldValue, formValues?: FieldValues) => boolean | Promise<boolean>;
}
export interface FieldConfig {
    name: string;
    defaultValue?: FieldValue;
    rules?: ValidationRule[];
    asyncRules?: ValidationRule[];
    debounceMs?: number;
    validateOnChange?: boolean;
    validateOnBlur?: boolean;
    transform?: (value: FieldValue) => FieldValue;
    format?: (value: FieldValue) => string;
    parse?: (value: string) => FieldValue;
}
export interface FormConfig {
    initialValues?: FieldValues;
    validateOnChange?: boolean;
    validateOnBlur?: boolean;
    validateOnSubmit?: boolean;
    resetOnSubmit?: boolean;
    enableReinitialize?: boolean;
    onSubmit?: (values: FieldValues, form: FormInstance) => void | Promise<void>;
    onValidationError?: (errors: Record<string, FieldError>, form: FormInstance) => void;
    onReset?: (form: FormInstance) => void;
}
export interface FormInstance {
    getState(): FormState;
    getFieldState(name: string): FieldState | undefined;
    getValues(): FieldValues;
    getValue(name: string): FieldValue;
    getErrors(): Record<string, FieldError>;
    getError(name: string): FieldError | null;
    setValue(name: string, value: FieldValue, shouldValidate?: boolean): void;
    setValues(values: FieldValues, shouldValidate?: boolean): void;
    setError(name: string, error: FieldError): void;
    setErrors(errors: Record<string, FieldError>): void;
    clearError(name: string): void;
    clearErrors(): void;
    registerField(config: FieldConfig): () => void;
    unregisterField(name: string): void;
    touchField(name: string): void;
    untouchField(name: string): void;
    focusField(name: string): void;
    blurField(name: string): void;
    validateField(name: string): Promise<boolean>;
    validateForm(): Promise<boolean>;
    isValid(): boolean;
    isValidating(): boolean;
    submit(): Promise<void>;
    reset(values?: FieldValues): void;
    resetField(name: string, value?: FieldValue): void;
    isDirty(): boolean;
    isTouched(): boolean;
    isSubmitting(): boolean;
    hasBeenSubmitted(): boolean;
    getSubmitCount(): number;
    handleSubmit(event?: Event): Promise<void>;
    handleReset(event?: Event): void;
    handleFieldChange(name: string, value: FieldValue): void;
    handleFieldBlur(name: string): void;
    handleFieldFocus(name: string): void;
    subscribe(callback: (state: FormState) => void): () => void;
    subscribeToField(name: string, callback: (state: FieldState) => void): () => void;
}
export interface BaseValidationSchema {
    validate(values: FieldValues): Promise<Record<string, FieldError>>;
    validateField(name: string, value: FieldValue, values?: FieldValues): Promise<FieldError | null>;
}
export interface FormArrayInstance {
    fields: Array<{
        id: string;
        name: string;
    }>;
    append(value: FieldValue): void;
    prepend(value: FieldValue): void;
    insert(index: number, value: FieldValue): void;
    remove(index: number): void;
    move(from: number, to: number): void;
    swap(indexA: number, indexB: number): void;
    replace(index: number, value: FieldValue): void;
    clear(): void;
    length: number;
}
export interface FieldArrayConfig {
    name: string;
    defaultValue?: FieldValue[];
    minLength?: number;
    maxLength?: number;
    keyName?: string;
}
export interface ZodSchema {
    parse: (data: any) => any;
    safeParse: (data: any) => {
        success: boolean;
        data?: any;
        error?: any;
    };
}
export interface YupSchema {
    validate: (data: any) => Promise<any>;
    validateSync: (data: any) => any;
    isValid: (data: any) => Promise<boolean>;
}
export interface JoiSchema {
    validate: (data: any) => {
        error?: any;
        value?: any;
    };
    validateAsync: (data: any) => Promise<any>;
}
export type ValidationSchema = ZodSchema | YupSchema | JoiSchema;
export interface AccessibilityConfig {
    describedBy?: string;
    labelledBy?: string;
    required?: boolean;
    invalid?: boolean;
    errorId?: string;
    helpTextId?: string;
}
export interface StepConfig {
    id: string;
    title: string;
    description?: string;
    fields: string[];
    validationSchema?: ValidationSchema;
    onEnter?: (form: FormInstance) => void | Promise<void>;
    onExit?: (form: FormInstance) => void | Promise<void>;
    canProceed?: (form: FormInstance) => boolean;
}
export interface MultiStepFormConfig extends FormConfig {
    steps: StepConfig[];
    currentStep?: number;
    onStepChange?: (step: number, form: FormInstance) => void;
    onComplete?: (values: FieldValues, form: FormInstance) => void | Promise<void>;
}
export interface MultiStepFormInstance extends FormInstance {
    currentStep: number;
    totalSteps: number;
    isFirstStep: boolean;
    isLastStep: boolean;
    nextStep(): void;
    prevStep(): void;
    goToStep(step: number): void;
    canGoNext(): boolean;
    canGoPrev(): boolean;
    getCurrentStepConfig(): StepConfig;
    getStepProgress(): number;
}
//# sourceMappingURL=types.d.ts.map