Can you help me create a custom React hook called useFormValidator for a trading form…
- User
Can you help me create a custom React hook called useFormValidator for a trading form that needs to be super fast? I want it to use Zod for validation but run the validation in a Web Worker so it doesn't block the UI when users are typing quickly.
Assistant
This is a great question about creating a custom React hook that:
- Uses Zod for validation
- Runs validation in a Web Worker to avoid blocking the UI
- Is designed for a trading form (which suggests high-performance requirements)
- Should handle rapid input changes (fast typing)
This is a complex but practical use case. I'll need to create:
- A validation schema using Zod
- A Web Worker file for handling validation
- A custom React hook that communicates with the worker
- Example usage in a trading form component
Let me think through the key considerations:
- Web Workers can't access the DOM, so we need to pass serializable data
- We need proper error handling and cleanup
- We should debounce/throttle rapid validation requests to avoid overwhelming the worker
- TypeScript support would be nice
- We should handle worker initialization and termination properly
- Need to ensure the worker URL is correct
Here's my approach:
- Create a Zod schema file
- Create a validation worker file
- Create the useFormValidator hook
- Create example usage
- Add TypeScript types
- Add some considerations and optimizations
Let me structure this comprehensively:
Custom React Hook: useFormValidator with Web Worker
I'll create a complete solution for high-performance form validation using Zod in a Web Worker.
1. Validation Worker (
validationWorker.ts)import { z } from 'zod'; // Define your Zod schemas const tradingFormSchema = z.object({ symbol: z.string().min(1, 'Symbol required').max(10), quantity: z.coerce.number().positive('Quantity must be positive'), price: z.coerce.number().positive('Price must be positive'), orderType: z.enum(['market', 'limit', 'stop']), stopPrice: z.coerce.number().optional(), }).refine( (data) => data.orderType !== 'stop' || data.stopPrice, { message: 'Stop price required for stop orders', path: ['stopPrice'] } ); interface ValidationMessage { id: string; action: 'validate' | 'init'; data?: Record<string, any>; } interface ValidationResult { id: string; success: boolean; data?: Record<string, any>; errors?: Record<string, string[]>; } // Handle validation requests self.onmessage = (event: MessageEvent<ValidationMessage>) => { const { id, action, data } = event.data; try { if (action === 'validate') { const result = tradingFormSchema.safeParse(data); const response: ValidationResult = { id, success: result.success, ...(result.success ? { data: result.data } : { errors: result.error.flatten().fieldErrors as Record<string, string[]> } ), }; self.postMessage(response); } else if (action === 'init') { // Worker is ready self.postMessage({ id, success: true, action: 'ready' }); } } catch (error) { self.postMessage({ id, success: false, errors: { _form: [(error as Error).message] }, }); } };2. Custom Hook (
useFormValidator.ts)import { useCallback, useEffect, useRef, useState } from 'react'; interface ValidationError { [key: string]: string[]; } interface UseFormValidatorState { errors: ValidationError; isValidating: boolean; touched: Set<string>; } interface UseFormValidatorOptions { debounceMs?: number; validateOnBlur?: boolean; validateOnChange?: boolean; initialTouched?: string[]; } export function useFormValidator( options: UseFormValidatorOptions = {} ) { const { debounceMs = 300, validateOnBlur = true, validateOnChange = true, initialTouched = [], } = options; const [state, setState] = useState<UseFormValidatorState>({ errors: {}, isValidating: false, touched: new Set(initialTouched), }); const workerRef = useRef<Worker | null>(null); const debounceTimeoutRef = useRef<NodeJS.Timeout>(); const pendingValidationRef = useRef<Map<string, Record<string, any>>>( new Map() ); const validationIdRef = useRef(0); // Initialize worker useEffect(() => { try { // For webpack/bundlers, use new Worker() syntax // For Vite, use ?worker import // For plain JS, use worker file path workerRef.current = new Worker( new URL('./validationWorker.ts', import.meta.url), { type: 'module' } ); // Handle messages from worker workerRef.current.onmessage = (event) => { const { id, success, data, errors } = event.data; if (success) { // Only update if this is the latest validation setState((prev) => { if (prev.isValidating) { return { ...prev, isValidating: false, errors: {}, }; } return prev; }); } else { setState((prev) => ({ ...prev, isValidating: false, errors: errors || {}, })); } pendingValidationRef.current.delete(String(id)); }; workerRef.current.onerror = (error) => { console.error('Worker error:', error); setState((prev) => ({ ...prev, isValidating: false, errors: { _form: ['Validation service error'] }, })); }; } catch (error) { console.error('Failed to initialize worker:', error); } return () => { workerRef.current?.terminate(); }; }, []); // Cleanup debounce on unmount useEffect(() => { return () => { if (debounceTimeoutRef.current) { clearTimeout(debounceTimeoutRef.current); } }; }, []); const validate = useCallback( (formData: Record<string, any>, immediateValidation = false) => { if (!workerRef.current) return; // Clear previous timeout if immediate validation if (immediateValidation && debounceTimeoutRef.current) { clearTimeout(debounceTimeoutRef.current); } const executeValidation = () => { setState((prev) => ({ ...prev, isValidating: true })); const validationId = ++validationIdRef.current; pendingValidationRef.current.set(String(validationId), formData); workerRef.current!.postMessage({ id: validationId, action: 'validate', data: formData, }); }; if (immediateValidation) { executeValidation(); } else { debounceTimeoutRef.current = setTimeout( executeValidation, debounceMs ); } }, [debounceMs] ); const markTouched = useCallback((fieldName: string) => { setState((prev) => { const newTouched = new Set(prev.touched); newTouched.add(fieldName); return { ...prev, touched: newTouched }; }); }, []); const markTouchedMultiple = useCallback((fieldNames: string[]) => { setState((prev) => { const newTouched = new Set(prev.touched); fieldNames.forEach((name) => newTouched.add(name)); return { ...prev, touched: newTouched }; }); }, []); const resetErrors = useCallback(() => { setState((prev) => ({ ...prev, errors: {}, touched: new Set() })); }, []); const getFieldError = useCallback( (fieldName: string): string | undefined => { return state.errors[fieldName]?.[0]; }, [state.errors] ); const getFieldErrors = useCallback( (fieldName: string): string[] => { return state.errors[fieldName] || []; }, [state.errors] ); const getFieldTouched = useCallback( (fieldName: string): boolean => { return state.touched.has(fieldName); }, [state.touched] ); const getFieldMeta = useCallback( (fieldName: string) => ({ error: getFieldError(fieldName), errors: getFieldErrors(fieldName), touched: getFieldTouched(fieldName), }), [getFieldError, getFieldErrors, getFieldTouched] ); return { errors: state.errors, isValidating: state.isValidating, touched: state.touched, validate, markTouched, markTouchedMultiple, resetErrors, getFieldError, getFieldErrors, getFieldTouched, getFieldMeta, }; }3. Example Trading Form Component
import React, { useCallback, useState } from 'react'; import { useFormValidator } from './useFormValidator'; interface TradingFormData { symbol: string; quantity: number; price: number; orderType: 'market' | 'limit' | 'stop'; stopPrice?: number; } export function TradingForm() { const [formData, setFormData] = useState<TradingFormData>({ symbol: '', quantity: 0, price: 0, orderType: 'market', }); const [isSubmitting, setIsSubmitting] = useState(false); const validator = useFormValidator({ debounceMs: 200, // Fast validation for trading validateOnChange: true, }); const handleChange = useCallback( (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => { const { name, value } = e.target; const newData = { ...formData, [name]: name === 'quantity' || name === 'price' || name === 'stopPrice' ? parseFloat(value) : value, }; setFormData(newData); // Validate on change validator.validate(newData); }, [formData, validator] ); const handleBlur = useCallback( (e: React.FocusEvent<HTMLInputElement | HTMLSelectElement>) => { const { name } = e.target; validator.markTouched(name); // Immediate validation on blur validator.validate(formData, true); }, [formData, validator] ); const handleSubmit = useCallback( async (e: React.FormEvent) => { e.preventDefault(); // Validate immediately before submit validator.validate(formData, true); // Wait a tick for validation to complete await new Promise((resolve) => setTimeout(resolve, 0)); if (Object.keys(validator.errors).length === 0) { setIsSubmitting(true); try { // Submit to API console.log('Submitting:', formData); // await submitOrder(formData); } finally { setIsSubmitting(false); } } }, [formData, validator] ); const renderField = ( name: keyof TradingFormData, label: string, type: string = 'text' ) => { const { error, touched } = validator.getFieldMeta(name); const shouldShowError = touched && error; return ( <div key={name} className="form-group"> <label htmlFor={name}>{label}</label> <input id={name} name={name} type={type} value={formData[name] || ''} onChange={handleChange} onBlur={handleBlur} className={`form-input ${shouldShowError ? 'error' : ''}`} disabled={validator.isValidating} /> {shouldShowError && ( <span className="error-message">{error}</span> )} </div> ); }; return ( <form onSubmit={handleSubmit} className="trading-form"> <h2>Trading Form</h2> {renderField('symbol', 'Symbol (e.g., AAPL)', 'text')} {renderField('quantity', 'Quantity', 'number')} {renderField('price', 'Price', 'number')} <div className="form-group"> <label htmlFor="orderType">Order Type</label> <select id="orderType" name="orderType" value={formData.orderType} onChange={handleChange} onBlur={handleBlur} > <option value="market">Market</option> <option value="limit">Limit</option> <option value="stop">Stop</option> </select> </div> {formData.orderType === 'stop' && renderField('stopPrice', 'Stop Price', 'number')} {validator.isValidating && ( <div className="validating-indicator"> Validating... ✓ </div> )} <button type="submit" disabled={ isSubmitting || validator.isValidating || Object.keys(validator.errors).length > 0 } > {isSubmitting ? 'Submitting...' : 'Place Order'} </button> {Object.keys(validator.errors).length > 0 && ( <div className="form-errors"> {Object.entries(validator.errors).map(([field, errors]) => ( <div key={field}> {errors.map((error, idx) => ( <p key={idx}>{error}</p> ))} </div> ))} </div> )} </form> ); }4. Styling
.trading-form { max-width: 500px; margin: 20px auto; padding: 20px; border: 1px solid #e0e0e0; border-radius: 8px; } .form-group { margin-bottom: 16px; display: flex; flex-direction: column; } .form-group label { margin-bottom: 6px; font-weight: 500; color: #333; } .form-input { padding: 10px 12px; border: 1px solid #ddd; border-radius: 4px; font-size: 14px; transition: border-color 0.2s; } .form-input:focus { outline: none; border-color: #2563eb; box-shadow: 0 0 0 2px rgba(37, 99, 235, 0.1); } .form-input.error { border-color: #dc2626; } .error-message { color: #dc2626; font-size: 12px; margin-top: 4px; } .validating-indicator { padding: 8px 12px; background-color: #f0fdf4; border: 1px solid #bbf7d0; border-radius: 4px; color: #166534; font-size: 13px; margin-bottom: 12px; } .form-errors { margin-top: 12px; padding: 12px; background-color: #fef2f2; border: 1px solid #fecaca; border-radius: 4px; color: #991b1b; } button { background-color: #2563eb; color: white; padding: 10px 16px; border: none; border-radius: 4px; font-size: 14px; font-weight: 600; cursor: pointer; transition: background-color 0.2s; width: 100%; } button:hover:not(:disabled) { background-color: #1d4ed8; } button:disabled { background-color: #d1d5db; cursor: not-allowed; }5. Webpack Configuration (if needed)
// webpack.config.js module.exports = { module: { rules: [ { test: /Worker\.ts$/, use: { loader: 'worker-loader' }, }, ], }, };6. Vite Configuration (Recommended)
// vite.config.ts import { defineConfig } from 'vite'; import react from '@vitejs/plugin-react'; export default defineConfig({ plugins: [react()], worker: { format: 'es', }, }); // Update import in useFormValidator.ts workerRef.current = new Worker( new URL('./validationWorker.ts', import.meta.url), { type: 'module' } );Key Features
✅ Non-blocking UI - Validation runs off the main thread
✅ Debounced - Prevents excessive validation requests
✅ TypeScript support - Full type safety
✅ Field-level tracking - Know which fields are touched/have errors
✅ Async ready - Hook properly manages worker lifecycle
✅ Error handling - Graceful fallbacks if worker fails
✅ Memory efficient - Proper cleanup and garbage collectionPerformance Tips
- Use
debounceMs: 200-300for trading forms (balance between UX and performance) - Mark fields as touched on blur for better UX
- Validate immediately on submit with
validate(data, true) - Consider batching validations for complex forms
Would you like me to add support for async validation, custom schema injection, or multiple validation schemas?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.