neumorphic-peripheral/dist/adapters/yup.d.ts

A lightweight, framework-agnostic JavaScript/TypeScript library for beautiful neumorphic styling

/**
 * Yup Validation Adapter for Neumorphic Peripheral
 *
 * This adapter allows you to use Yup schemas for validation
 * Install: npm install yup
 *
 * Usage:
 * import * as yup from 'yup'
 * import { yupAdapter } from 'neumorphic-peripheral/adapters/yup'
 *
 * const schema = yup.string().email().min(5)
 * np.input(element, { validate: yupAdapter(schema) })
 */
import { ValidationFunction, ValidationResult } from '../types';
type YupSchema = any;
/**
 * Creates a validation function from a Yup schema
 */
export declare function yupAdapter(schema: YupSchema): ValidationFunction;
/**
 * Creates a comprehensive validation function that returns all errors
 */
export declare function yupAdapterDetailed(schema: YupSchema): (value: string) => ValidationResult;
/**
 * Async validation adapter for Yup schemas
 */
export declare function yupAdapterAsync(schema: YupSchema): (value: string) => Promise<ValidationResult>;
/**
 * Schema builder utilities for common patterns
 */
export declare const yupSchemas: {
    email: () => Promise<any>;
    password: (minLength?: number) => Promise<any>;
    phone: () => Promise<any>;
    url: () => Promise<any>;
    required: (message?: string) => Promise<any>;
    number: (min?: number, max?: number) => Promise<any>;
};
/**
 * Form-level validation using Yup
 */
export declare class YupFormValidator {
    private schema;
    private fields;
    constructor(schema: YupSchema);
    /**
     * Register a field with its schema key
     */
    registerField(element: HTMLElement, key: string): void;
    /**
     * Validate a specific field
     */
    validateField(element: HTMLElement): Promise<ValidationResult>;
    /**
     * Validate entire form
     */
    validateForm(): Promise<{
        isValid: boolean;
        errors: Record<string, string[]>;
        data?: any;
    }>;
    private getElementValue;
}
/**
 * Helper function to create form validator
 */
export declare function createYupFormValidator(schema: YupSchema): YupFormValidator;
/**
 * Integration with neumorphic components
 */
export declare const yupIntegration: {
    /**
     * Setup form validation with Yup schema
     */
    setupForm(formElement: HTMLFormElement, schema: YupSchema, components: Record<string, any>): Promise<YupFormValidator>;
    /**
     * Setup field-level validation with conditional schemas
     */
    setupConditionalValidation(component: any, schemaBuilder: (formData: Record<string, any>) => YupSchema, getFormData: () => Record<string, any>): void;
};
/**
 * Advanced Yup utilities for neumorphic components
 */
export declare const yupUtils: {
    /**
     * Create a cross-field validation schema
     */
    createCrossFieldValidation: (dependencies: string[]) => Promise<any>;
    /**
     * Create async validation (e.g., for username availability)
     */
    createAsyncValidation: (checkFunction: (value: string) => Promise<boolean>, errorMessage?: string) => Promise<any>;
    /**
     * Create conditional validation based on other fields
     */
    createConditionalValidation: (condition: (formData: any) => boolean, trueSchema: any, falseSchema?: any) => Promise<any>;
};
export declare const examples: {
    basicField: string;
    asyncValidation: string;
    complexForm: string;
};
export {};
//# sourceMappingURL=yup.d.ts.map