Skip to content

The Open Standard for Generative UI

3.1 KB
Raw Blame
import { validate, type ParsedRule } from "@openuidev/lang-core";
import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";

export interface FormValidationContextValue {
  errors: Record<string, string | undefined>;
  getFieldError: (name: string) => string | undefined;
  validateField: (name: string, value: unknown, rules: ParsedRule[]) => boolean;
  registerField: (name: string, rules: ParsedRule[], getValue: () => unknown) => void;
  unregisterField: (name: string) => void;
  validateForm: () => boolean;
  clearFieldError: (name: string) => void;
}

export const FormValidationContext = createContext<FormValidationContextValue | null>(null);

export function useFormValidation(): FormValidationContextValue | null {
  return useContext(FormValidationContext);
}

interface FieldRegistration {
  rules: ParsedRule[];
  getValue: () => unknown;
}

export function useCreateFormValidation(): FormValidationContextValue {
  const [errors, setErrors] = useState<Record<string, string | undefined>>({});
  const errorsRef = useRef(errors);
  errorsRef.current = errors;
  const fieldsRef = useRef<Record<string, FieldRegistration>>({});

  const getFieldError = useCallback((name: string) => errorsRef.current[name], []);

  const validateField = useCallback(
    (name: string, value: unknown, rules: ParsedRule[]): boolean => {
      const error = validate(value, rules);
      setErrors((prev) => {
        if (prev[name] === error) return prev;
        return { ...prev, [name]: error };
      });
      return !error;
    },
    [],
  );

  const registerField = useCallback(
    (name: string, rules: ParsedRule[], getValue: () => unknown) => {
      fieldsRef.current[name] = { rules, getValue };
    },
    [],
  );

  const unregisterField = useCallback((name: string) => {
    delete fieldsRef.current[name];
  }, []);

  const validateForm = useCallback((): boolean => {
    let allValid = true;
    const newErrors: Record<string, string | undefined> = {};

    for (const [name, reg] of Object.entries(fieldsRef.current)) {
      let value = reg.getValue();
      // Normalize: form state stores { value, componentType }; extract actual value if needed
      if (
        value != null &&
        typeof value === "object" &&
        "value" in value &&
        "componentType" in value
      ) {
        value = (value as { value: unknown }).value;
      }
      const error = validate(value, reg.rules);
      newErrors[name] = error;
      if (error) allValid = false;
    }

    setErrors(newErrors);
    return allValid;
  }, []);

  const clearFieldError = useCallback((name: string) => {
    setErrors((prev) => {
      if (prev[name] === undefined) return prev;
      return { ...prev, [name]: undefined };
    });
  }, []);

  return useMemo<FormValidationContextValue>(
    () => ({
      errors,
      getFieldError,
      validateField,
      registerField,
      unregisterField,
      validateForm,
      clearFieldError,
    }),
    [
      errors,
      getFieldError,
      validateField,
      registerField,
      unregisterField,
      validateForm,
      clearFieldError,
    ],
  );
}