npm - @juantroconisf/lib - Versions diffs - 7.0.0 → 8.0.0 - Mend

@juantroconisf/lib 7.0.0 → 8.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,10 +1,3 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 // src/utils/types.ts
 var NextUIError = class {
   isInvalid;
@@ -26,7 +19,7 @@ function handleNestedChange({
   hasNestedValues = false
 }) {
   if (!hasNestedValues) return { ...state, [id]: value };
-  const propertyDepth = String(id).split("."), newValues = state;
+  const propertyDepth = String(id).split("."), newValues = { ...state };
   let current = newValues;
   for (let i = 0; i < propertyDepth.length - 1; i++) {
     const key = propertyDepth[i];
@@ -62,141 +55,131 @@ function handleArrayItemChange({
 function getNestedValue(obj, path) {
   return path.split(".").reduce((acc, key) => acc?.[key], obj);
 }
-function removeCompositeKeysByPrefix(map2, prefix) {
-  const result = new Map(map2);
-  for (const key of map2.keys()) {
+function removeCompositeKeysByPrefix(map, prefix) {
+  const result = new Map(map);
+  for (const key of map.keys()) {
     if (key.startsWith(prefix)) {
       result.delete(key);
     }
   }
   return result;
 }
-function setNestedValue(state, dotPath, value) {
-  const keys = dotPath.split(".");
-  const copy = { ...state };
-  let current = copy;
-  for (let i = 0; i < keys.length - 1; i++) {
-    current[keys[i]] = { ...current[keys[i]] };
-    current = current[keys[i]];
-  }
-  current[keys[keys.length - 1]] = value;
-  return copy;
-}
-var regex = {
-  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-  password: /^(?!.*\s)(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[~`!@#$%^&*()--+={}[\]|:;"'<>,.?/_₹]).{8,24}$/
-};
-var map = {
-  string: (val) => Boolean(val),
-  number: (val) => String(val) !== "",
-  object: (val) => val !== null && Object.keys(val).length > 0
-};
-var requiredValidation = (value) => Array.isArray(value) ? value.length > 0 : map[typeof value](value);
-var errors = {
-  required: {
-    validate: (val, isRequired) => !isRequired || requiredValidation(val),
-    msg: "REQUIRED"
-  },
-  min: {
-    validate: (val, min) => val >= min,
-    msg: "VALUE_LOW"
-  },
-  max: {
-    validate: (val, max) => val <= max,
-    msg: "VALUE_HIGH"
-  },
-  minLength: {
-    validate: (val = "", min) => val.length >= min,
-    msg: "TOO_SHORT"
-  },
-  maxLength: {
-    validate: (val = "", max) => val.length <= max,
-    msg: "TOO_LONG"
-  },
-  pattern: {
-    validate: (val, pattern) => new RegExp(pattern).test(val),
-    msg: "PATTERN_INVALID"
-  },
-  equal: {
-    validate: (val, comparison) => val === comparison,
-    msg: "NOT_EQUAL"
-  },
-  numberIsEqual: {
-    validate: (val, comparison) => val === comparison,
-    msg: "NOT_EQUAL"
-  },
-  email: {
-    validate: (val) => new RegExp(regex.email).test(val),
-    msg: "INVALID_EMAIL"
-  },
-  password: {
-    validate: (val) => new RegExp(regex.password).test(val),
-    msg: "INVALID_PASSWORD"
+// src/hooks/useComponentLang.tsx
+import { setLocale } from "yup";
+import { useEffect } from "react";
+// src/assets/translations.ts
+var translations = {
+  en: {
+    mixed: {
+      default: "Invalid value",
+      required: "This field is required",
+      oneOf: "Must be one of: ${values}",
+      notOneOf: "Cannot be any of: ${values}",
+      notType: "Incorrect data format",
+      defined: "Must be defined"
+    },
+    string: {
+      length: "Must be exactly ${length} characters",
+      min: "Must be at least ${min} characters",
+      max: "Must be at most ${max} characters",
+      matches: 'Must match: "${regex}"',
+      email: "Enter a valid email address",
+      url: "Enter a valid URL",
+      uuid: "Enter a valid UUID",
+      trim: "Remove leading/trailing spaces",
+      lowercase: "Must be in lowercase",
+      uppercase: "Must be in uppercase",
+      password: "Your password doesn't meet the security criteria."
+    },
+    number: {
+      min: "Value must be ${min} or greater",
+      max: "Value must be ${max} or less",
+      lessThan: "Must be less than ${less}",
+      moreThan: "Must be greater than ${more}",
+      positive: "Must be a positive number",
+      negative: "Must be a negative number",
+      integer: "Must be a whole number"
+    },
+    date: {
+      min: "Date must be after ${min}",
+      max: "Date must be before ${max}"
+    },
+    boolean: {
+      isValue: "Must be ${value}"
+    },
+    object: {
+      noUnknown: "Contains unknown properties"
+    },
+    array: {
+      min: "Must have at least ${min} items",
+      max: "Must have ${max} items or fewer",
+      length: "Must have exactly ${length} items"
+    }
   },
-  custom: {
-    validate: (_, bool) => bool,
-    msg: "INVALID"
+  es: {
+    mixed: {
+      default: "Valor no v\xE1lido",
+      required: "Este campo es obligatorio",
+      oneOf: "Debe ser uno de: ${values}",
+      notOneOf: "No puede ser ninguno de: ${values}",
+      defined: "Debe estar definido",
+      notType: "Formato de dato incorrecto"
+    },
+    string: {
+      length: "Debe tener exactamente ${length} caracteres",
+      min: "Debe tener al menos ${min} caracteres",
+      max: "Debe tener como m\xE1ximo ${max} caracteres",
+      matches: 'Debe coincidir con: "${regex}"',
+      email: "Ingresa un correo electr\xF3nico v\xE1lido",
+      url: "Ingresa una URL v\xE1lida",
+      uuid: "Ingresa un UUID v\xE1lido",
+      trim: "No debe contener espacios al inicio o final",
+      lowercase: "Debe estar en min\xFAsculas",
+      uppercase: "Debe estar en may\xFAsculas",
+      password: "Tu contrase\xF1a no cumple con los requisitos de seguridad."
+    },
+    number: {
+      min: "Debe ser mayor o igual a ${min}",
+      max: "Debe ser menor o igual a ${max}",
+      lessThan: "Debe ser menor a ${less}",
+      moreThan: "Debe ser mayor a ${more}",
+      positive: "Debe ser un n\xFAmero positivo",
+      negative: "Debe ser un n\xFAmero negativo",
+      integer: "Debe ser un n\xFAmero entero"
+    },
+    date: {
+      min: "La fecha debe ser posterior a ${min}",
+      max: "La fecha debe ser anterior a ${max}"
+    },
+    boolean: {
+      isValue: "Debe ser ${value}"
+    },
+    object: {
+      noUnknown: "Contiene propiedades no permitidas"
+    },
+    array: {
+      min: "Debe tener al menos ${min} elementos",
+      max: "Debe tener como m\xE1ximo ${max} elementos",
+      length: "Debe tener ${length} elementos"
+    }
   }
 };
-// lang/en.json
-var en_default = { BIRTH_DATE: "Birth date", DAY: "Day", DAY_PLACEHOLDER: "Choose a day", MONTH: "Month", MONTH_PLACEHOLDER: "Choose a month", YEAR: "Year", YEAR_PLACEHOLDER: "Choose a year", PRICING: "Pricing", PRICING_TABLE: "Pricing table", OUR_PRICING_PLAN: "Our pricing plan", PRICING_DESCRIPTION: "Level up your experience. Discover the plan that unlocks the features you need.", VALUE_STORAGE: "{{value}} storage", GOOGLE_CALENDAR_SYNC: "Google Calendar Sync", INTERNAL_REMINDERS: "Internal reminders", WHATSAPP_AUTOMATED_REMINDERS: "WhatsApp Automated Reminders", PROFESSIONAL: "Professional", PROFESSIONAL_PLAN_DESCRIPTION: "For single doctors looking to level up their practice", DIGITAL_PRESCRIPTIONS: "Digital prescriptions", DICOM_VIEWER: "DICOM Viewer", VERIFIED_MEDICAL_CREDENTIALS: "Verified medical credentials", PATIENT_SELF_MANAGEMENT: "Patient self management", BUY_NOW: "Buy now", ORGANIZATION: "Organization", ORGANIZATION_PLAN_DESCRIPTION: "For organizations with multiple users looking to share information", UP_TO_VALUE_STORAGE: "Up to {{value}} storage", CONFIGURABLE_USER_PERMISSIONS: "Configurable user permissions", CALCULATE_PRICING: "Calculate pricing", DOCTORS: "Doctors", ASSISTANTS: "Assistants", BASIC: "Basic", BASIC_PLAN_DESCRIPTION: "For starters in the medical industry", USER: "User", TYPE_A_VALUE: "Type a value", STORAGE: "Storage", PASSWORD: "Password", PASSWORD_PLACEHOLDER: "Enter your password", REQUIRED: "Required", TOO_SHORT: "Too short", TOO_LONG: "Too long", VALUE_LOW: "Value is too low", VALUE_HIGH: "Value is too high", PATTERN_INVALID: "Pattern is not valid", INVALID_EMAIL: "Invalid email", SHOW_PASSWORD: "Show password", HIDE_PASSWORD: "Hide password", GROUP_PRICING_CALCULATOR: "Group Pricing Calculator", VERIFIED_ACCOUNT: "Verified account", VERIFIED_ACCOUNT_TEXT: "This account has been verified by Clinikos, as well as its affiliations with the following institutions", PHONE_NUMBER: "Phone number", PHONE_NUMBER_PLACEHOLDER: "Enter your phone number", SEND_MESSAGE: "Send message", BOOK_MEETING: "Book meeting", SIGN_UP: "Sign up", INVALID_PASSWORD: "Your password doesn't meet the security criteria.", NOT_EQUAL: "Values are not equal", GENDER: "Gender", FEMALE: "Female", MALE: "Male", CLOSE: "Close", MANDATORY_FIELDS_WARNING: "", INVALID_FIELDS_WARNING: "", COUNTRY: "Country", COUNTRY_PLACEHOLDER: "Select a country", STATE: "State", STATE_PLACEHOLDER: "Select a state", CITY: "City", CITY_PLACEHOLDER: "Select a city", TIMEZONE: "Timezone", TIMEZONE_PLACEHOLDER: "Selecte a timezone", NAME: "Name", OK: "Ok", PAGE_NOT_FOUND: "Page not found", PAGE_NOT_FOUND_DESCRIPTION: "The link you clicked may be broken or the page may have been removed or renamed", TODAY: "Today", WEEK: "Week", CALENDAR: "Calendar", EVENT: "Event", NO_INFORMATION: "No information", SYNC_GOOGLE_CALENDAR: "Sync Google Calendar", NO_RESULTS: "No results were found", GOOGLE_MEET: "Google Meet", LONG_TIME_AGO: "Long time ago", TOMORROW: "Tomorrow", CHOOSE_PLAN: "Choose a plan", CHOOSE_PLAN_DESCRIPTION: "Choose a plan that fits your needs!", PRIVACY_POLICY: "", OPTIONAL: "Optional", RESULTS: "Results", LOCATION: "Location", ADDRESS: "Address", ADDRESS_PLACEHOLDER: "Enter your address", COPY_TO_CLIPBOARD: "Copy to clipboard", ACTIONS: "Actions", MIN: "Minimum", MAX: "Maximum", DUE_DATE: "Due date", QUICK_SEARCH: "Quick search", MONTHLY: "Monthly", WEEKLY: "Weekly", GOOGLE_MAPS_LINK: "Google maps link", MINUTE: "Minute", MINUTES: "Minutes", HOUR: "Hour", HOURS: "Hours", VE_ID: "Identity card", ACCOUNT_VERIFIED_BY_CLINIKOS: "This account has been verified by Clinikos, as well as its affiliations with the following institutions", INBOX: "Inbox", ACCEPTED: "Accepted", DECLINED: "Declined", NEEDS_ACTION: "Needs action", OVERDUE: "Overdue", FILTER_BY: "Filter by", REFRESH: "Refresh", LOADING: "Loading", MINUTE_LEFT: "One minute left", VALUE_MINUTES_LEFT: "{{value}} minutes left", PLAY: "Play", PAUSE: "Pause", STOP: "Stop", LOAD_MORE: "Load more", BILLING: "Billing", DOCTOR: "Doctor", ASSISTANT: "Assistant", NUMBER_OF_DOCTORS: "Number of Doctors", NUMBER_OF_ASSISTANTS: "Number of Assistants", EACH_DOCTOR: "Each doctor", EACH_ASSISTANT: "Each assistant", ROLE: "Role", PAYMENT_METHODS: "Payment methods", UPGRADE: "Upgrade", TOTAL: "Total", BUY: "Buy", TYPE: "Type", RECURRENT: "Recurrent", ACCEPT: "Accept", DECLINE: "Decline", PREFERENCES: "Preferences", BOOKING: "Booking", PATTERN_NOT_VALID: "Pattern is not valid" };
-// lang/es.json
-var es_default = { BIRTH_DATE: "Fecha de nacimiento", DAY: "D\xEDa", DAY_PLACEHOLDER: "Elige un d\xEDa", MONTH: "Mes", MONTH_PLACEHOLDER: "Elige un mes", YEAR: "A\xF1o", YEAR_PLACEHOLDER: "Elige un a\xF1o", PRICING: "Precio", PRICING_TABLE: "Tabla de precios", OUR_PRICING_PLAN: "Nuestros precios", PRICING_DESCRIPTION: "Mejora tu experiencia. Descubre el plan que desbloquea las funciones que necesitas.", VALUE_STORAGE: "{{value}} almacenamiento", GOOGLE_CALENDAR_SYNC: "Google Calenar Sync", INTERNAL_REMINDERS: "Recordatorios internos", WHATSAPP_AUTOMATED_REMINDERS: "Recordatorios automatizados de WhatsApp", PROFESSIONAL: "Profesional", PROFESSIONAL_PLAN_DESCRIPTION: "Para doctores individuales que buscan elevar sus pr\xE1cticas", DIGITAL_PRESCRIPTIONS: "Recipes digitales", DICOM_VIEWER: "Visualizador DICOM", VERIFIED_MEDICAL_CREDENTIALS: "Credenciales m\xE9dicas verificadas", PATIENT_SELF_MANAGEMENT: "Auto gesti\xF3n para pacientes", BUY_NOW: "Comprar ahora", ORGANIZATION: "Organizaci\xF3n", ORGANIZATION_PLAN_DESCRIPTION: "Para organizaciones con m\xFAltiples usuarios que buscan compartir informaci\xF3n", UP_TO_VALUE_STORAGE: "Hasta {{value}} de almacenamiento", CONFIGURABLE_USER_PERMISSIONS: "Permisolog\xEDa configurable para usuarios", CALCULATE_PRICING: "Calcular precio", DOCTORS: "Doctores", ASSISTANTS: "Asistentes", BASIC: "B\xE1sico", BASIC_PLAN_DESCRIPTION: "Para iniciar en la industria m\xE9dica", USER: "Usuario", TYPE_A_VALUE: "Ingresa un valor", STORAGE: "Almacenamiento", PASSWORD: "Contrase\xF1a", PASSWORD_PLACEHOLDER: "Ingresa tu contrase\xF1a", REQUIRED: "Requerido", TOO_SHORT: "Demasiado corto", TOO_LONG: "Demasiado largo", VALUE_LOW: "El valor es muy bajo", VALUE_HIGH: "El valor es muy alto", PATTERN_INVALID: "El patr\xF3n no es v\xE1lido", INVALID_EMAIL: "Correo inv\xE1lido", SHOW_PASSWORD: "Mostrar contrase\xF1a", HIDE_PASSWORD: "Esconder contrase\xF1a", GROUP_PRICING_CALCULATOR: "Calculadora de precios grupal", VERIFIED_ACCOUNT: "Cuenta verificada", VERIFIED_ACCOUNT_TEXT: "Esta cuenta ha sido verificada por Clinikos, as\xED como sus afiliaciones con las siguientes instituciones", PHONE_NUMBER: "N\xFAmero de tel\xE9fono", PHONE_NUMBER_PLACEHOLDER: "Ingrese su n\xFAmero de tel\xE9fono", SEND_MESSAGE: "Enviar mensaje", BOOK_MEETING: "Agendar cita", SIGN_UP: "Reg\xEDstrate", INVALID_PASSWORD: "Tu contrase\xF1a no cumple con los requisitos de seguridad.", NOT_EQUAL: "Los valores no son iguales", GENDER: "G\xE9nero", FEMALE: "Femenino", MALE: "Masculino", CLOSE: "Cerrar", MANDATORY_FIELDS_WARNING: "", INVALID_FIELDS_WARNING: "", COUNTRY: "Pa\xEDs", COUNTRY_PLACEHOLDER: "Selecciona un pa\xEDs", STATE: "Estado", STATE_PLACEHOLDER: "Selecciona un estado", CITY: "Ciudad", CITY_PLACEHOLDER: "Selecciona una ciudad", TIMEZONE: "Zona horaria", TIMEZONE_PLACEHOLDER: "Selecciona una zora horaria", NAME: "Nombre", OK: "Ok", PAGE_NOT_FOUND: "P\xE1gina no encontrada", PAGE_NOT_FOUND_DESCRIPTION: "El enlace en el que hiciste click puede que est\xE9 roto o la p\xE1gina puede haber sido eliminada o renombrada", TODAY: "Hoy", WEEK: "Semana", CALENDAR: "Calendario", EVENT: "Evento", NO_INFORMATION: "Sin informaci\xF3n", SYNC_GOOGLE_CALENDAR: "Vincular Calendario de Google", NO_RESULTS: "No se encontraron resultados", GOOGLE_MEET: "Google Meet", LONG_TIME_AGO: "Hace mucho tiempo", TOMORROW: "Ma\xF1ana", CHOOSE_PLAN: "Elige un plan", CHOOSE_PLAN_DESCRIPTION: "\xA1Elige el plan que se ajuste a tus necesidades!", PRIVACY_POLICY: "", OPTIONAL: "Opcional", RESULTS: "Resultados", LOCATION: "Ubicaci\xF3n", ADDRESS: "Direcci\xF3n", ADDRESS_PLACEHOLDER: "Ingresa tu direcci\xF3n", COPY_TO_CLIPBOARD: "Copiar al portapapeles", ACTIONS: "Acciones", MIN: "M\xEDnimo", MAX: "M\xE1ximo", DUE_DATE: "Fecha l\xEDmite", QUICK_SEARCH: "B\xFAsqueda r\xE1pida", MONTHLY: "Mensual", WEEKLY: "Semanal", GOOGLE_MAPS_LINK: "Link de Google Maps", MINUTE: "Minuto", MINUTES: "Minutos", HOUR: "Hora", HOURS: "Horas", VE_ID: "C\xE9dula de Identidad", ACCOUNT_VERIFIED_BY_CLINIKOS: "Esta cuenta ha sido verificada por Clinikos, as\xED como sus afiliaciones con las siguientes instituciones", INBOX: "Bandeja de entrada", ACCEPTED: "Aceptado", DECLINED: "Declinado", NEEDS_ACTION: "Necesita acci\xF3n", OVERDUE: "Atrasado", FILTER_BY: "Filtrar por", REFRESH: "Refrescar", LOADING: "Cargando", MINUTE_LEFT: "Un minuto restante", VALUE_MINUTES_LEFT: "{{value}} minutos restantes", PLAY: "Reproducir", PAUSE: "Pausar", STOP: "Detener", LOAD_MORE: "Cargar m\xE1s", BILLING: "Facturaci\xF3n", DOCTOR: "Doctor", ASSISTANT: "Asistente", NUMBER_OF_DOCTORS: "N\xFAmero de Doctores", NUMBER_OF_ASSISTANTS: "N\xFAmero de Asistentes", EACH_DOCTOR: "Cada doctor", EACH_ASSISTANT: "Cada asistente", ROLE: "Rol", PAYMENT_METHODS: "M\xE9todos de pago", UPGRADE: "Mejorar", TOTAL: "Total", BUY: "Comprar", TYPE: "Tipo", RECURRENT: "Recurrente", ACCEPT: "Aceptar", DECLINE: "Declinar", PREFERENCES: "Preferencias", BOOKING: "Agendar cita", PATTERN_NOT_VALID: "El patr\xF3n no es v\xE1lido" };
 // src/hooks/useComponentLang.tsx
 var cookieName = "LOCALE";
-var langMap = {
-  en: en_default,
-  es: es_default
-};
 var getClientCookie = () => {
   const value = "; " + document.cookie, decodedValue = decodeURIComponent(value), parts = decodedValue.split("; " + cookieName + "=");
   if (parts.length === 2) return parts.pop()?.split(";").shift();
 };
-var getServerCookie = () => {
-  try {
-    const { cookies } = __require("next/headers");
-    return cookies().get(cookieName)?.value;
-  } catch {
-    return "es";
-  }
-};
 function useComponentLanguage() {
-  const isServer = typeof window === "undefined", locale = (isServer ? getServerCookie() : getClientCookie()) || "en";
-  return {
-    locale,
-    lang: langMap[locale]
-  };
-}
-// src/hooks/useValidate.tsx
-var validProps = {
-  isInvalid: false,
-  errorMessage: ""
-};
-function useValidate() {
-  const { lang } = useComponentLanguage();
-  const performValidations = (value, validationTypes, errorMessages) => {
-    if (!validationTypes) return validProps;
-    const items = Object.entries(validationTypes), requiredExist = validationTypes?.required !== void 0, isRequired = requiredExist ? validationTypes.required : false;
-    if (value === "" && !isRequired) return validProps;
-    let errorFound = validProps;
-    for (const [key, opts] of items) {
-      if (opts === null) continue;
-      const { validate, msg } = errors[key], isInvalid = !validate(value, opts);
-      if (isInvalid) {
-        errorFound = {
-          isInvalid,
-          errorMessage: errorMessages?.[key] || lang[msg]
-        };
-        break;
-      }
+  useEffect(() => {
+    const locale = getClientCookie() || "en";
+    if (translations[locale]) {
+      setLocale(translations[locale]);
     }
-    return errorFound;
-  };
-  return { performValidations };
+  }, []);
 }
 // src/hooks/useForm.utils.ts
@@ -294,19 +277,36 @@ function resolveFieldData(args, state, getIndex, getNestedValue2) {
 }
 // src/hooks/useForm.tsx
-function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
-  const [state, setState] = useState(initialState);
-  const [touched, setTouched] = useState(/* @__PURE__ */ new Map());
-  const [errors2, setErrors] = useState(/* @__PURE__ */ new Map());
-  const { performValidations } = useValidate();
-  const stateRef = useRef(state);
-  const touchedRef = useRef(touched);
-  const errorsRef = useRef(errors2);
+import { isSchema, object, reach } from "yup";
+var DEFAULT_OPTIONS = {};
+function useForm(schema, { arrayIdentifiers } = DEFAULT_OPTIONS) {
+  const { initialState, validationSchema } = useMemo(() => {
+    const state2 = {};
+    const extractedRules = {};
+    Object.entries(schema).forEach(([key, value]) => {
+      if (isSchema(value)) {
+        try {
+          state2[key] = value.getDefault();
+        } catch {
+          state2[key] = void 0;
+        }
+        extractedRules[key] = value;
+      } else {
+        state2[key] = value;
+      }
+    });
+    return {
+      initialState: state2,
+      validationSchema: object().shape(extractedRules)
+    };
+  }, [schema]);
+  const [state, setState] = useState(initialState), [metadata, setMetadata] = useState(/* @__PURE__ */ new Map());
+  useComponentLanguage();
+  const stateRef = useRef(state), metadataRef = useRef(metadata);
   stateRef.current = state;
-  touchedRef.current = touched;
-  errorsRef.current = errors2;
+  metadataRef.current = metadata;
   const indexMap = useMemo(() => {
-    const map2 = /* @__PURE__ */ new Map();
+    const map = /* @__PURE__ */ new Map();
     const traverse = (current, path) => {
       if (!current || typeof current !== "object") return;
       if (Array.isArray(current)) {
@@ -322,7 +322,7 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
             traverse(item, `${path}.${index}`);
           }
         });
-        map2.set(path, itemMap);
+        map.set(path, itemMap);
       } else {
         Object.keys(current).forEach((key) => {
           const nextPath = path ? `${path}.${key}` : key;
@@ -331,105 +331,139 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
       }
     };
     traverse(state, "");
-    return map2;
+    return map;
   }, [state, arrayIdentifiers]);
   const indexMapRef = useRef(indexMap);
   indexMapRef.current = indexMap;
   const getIndex = useCallback((arrayKey, itemId) => {
     return indexMapRef.current.get(arrayKey)?.get(itemId);
   }, []);
-  const getRule = useCallback(
-    (path) => {
-      if (rules?.[path]) return rules[path];
-      const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
-      return rules?.[genericPath];
-    },
-    [rules]
-  );
-  const getMessage = useCallback(
-    (path) => {
-      if (messages?.[path]) return messages[path];
+  const ruleCache = useRef(/* @__PURE__ */ new Map());
+  useMemo(() => {
+    ruleCache.current.clear();
+  }, [validationSchema]);
+  const getRule = useCallback((path, schema2) => {
+    if (ruleCache.current.has(path)) {
+      return ruleCache.current.get(path);
+    }
+    let rule;
+    try {
+      rule = reach(schema2, path);
+    } catch {
       const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
-      return messages?.[genericPath];
+      try {
+        rule = reach(schema2, genericPath);
+      } catch {
+        rule = void 0;
+      }
+    }
+    ruleCache.current.set(path, rule);
+    return rule;
+  }, []);
+  const runValidation = useCallback(
+    (ruleDef, value, compositeKey) => {
+      if (isSchema(ruleDef)) {
+        try {
+          ruleDef.validateSync(value);
+          return false;
+        } catch (err) {
+          const error = {
+            isInvalid: true,
+            errorMessage: err.message || "Invalid"
+          };
+          setMetadata((prev) => {
+            const newMap = new Map(prev);
+            const currentMeta = newMap.get(compositeKey) || {
+              isTouched: false,
+              isInvalid: false,
+              errorMessage: ""
+            };
+            newMap.set(compositeKey, { ...currentMeta, ...error });
+            return newMap;
+          });
+          return true;
+        }
+      }
+      return false;
     },
-    [messages]
+    []
   );
   const validateField = useCallback(
-    (compositeKey, fieldPath, value, extraContext) => {
-      let ruleDef = getRule(fieldPath);
-      if (!ruleDef) {
-        const stripped = fieldPath.replace(/\.@\d+/g, "").replace(/\.@\d+$/, "");
-        if (stripped !== fieldPath) ruleDef = getRule(stripped);
+    (compositeKey, fieldPath, value) => {
+      let schemaRule = getRule(fieldPath, validationSchema);
+      if (schemaRule) {
+        if (runValidation(schemaRule, value, compositeKey)) return true;
       }
-      const rule = typeof ruleDef === "function" ? ruleDef(
-        value,
-        stateRef.current,
-        extraContext?.item,
-        extraContext?.index
-      ) : ruleDef;
-      let message = getMessage(fieldPath);
-      if (!message && fieldPath !== fieldPath.replace(/\.@\d+/, "")) {
-        message = getMessage(fieldPath.replace(/\.@\d+/, ""));
-      }
-      const error = performValidations(value, rule, message);
-      setErrors((prev) => {
+      setMetadata((prev) => {
         const newMap = new Map(prev);
-        newMap.set(compositeKey, error);
+        const currentMeta = newMap.get(compositeKey) || {
+          isTouched: false,
+          isInvalid: false,
+          errorMessage: ""
+        };
+        newMap.set(compositeKey, {
+          ...currentMeta,
+          isInvalid: false,
+          errorMessage: ""
+        });
         return newMap;
       });
-      return error.isInvalid;
+      return false;
     },
-    [getRule, getMessage, performValidations]
+    [getRule, runValidation, validationSchema]
   );
   const validateAll = useCallback(() => {
-    if (!rules) return false;
-    const nextErrors = /* @__PURE__ */ new Map();
-    let hasInvalid = false;
-    const processRule = (ruleKey, ruleVal) => {
-      const isGeneric = !ruleKey.match(/\.\d+\./) && !ruleKey.match(/\.@\d+/);
-      const parts = ruleKey.split(".");
-      let arrayKey = "";
-      let arrayIndexInPath = -1;
-      for (let i = 0; i < parts.length; i++) {
-        if (indexMapRef.current.has(parts[i])) {
-          arrayKey = parts[i];
-          arrayIndexInPath = i;
-          break;
-        }
-      }
-      if (arrayKey && arrayIndexInPath !== -1) {
-        const itemMap = indexMapRef.current.get(arrayKey);
-        if (itemMap) {
-          itemMap.forEach((idx, itemId) => {
-            const suffix = parts.slice(arrayIndexInPath + 1).join(".");
-            const compositeKey = `${arrayKey}.${itemId}` + (suffix ? `.${suffix}` : "");
-            const item = stateRef.current[arrayKey][idx];
-            const val = getNestedValue(item, suffix);
-            const rule = typeof ruleVal === "function" ? ruleVal(val, stateRef.current, item, idx) : ruleVal;
-            const msg = getMessage(ruleKey);
-            const err = performValidations(val, rule, msg);
-            nextErrors.set(compositeKey, err);
-            if (err.isInvalid) hasInvalid = true;
+    if (!validationSchema) return false;
+    let hasError = false;
+    const newMetadata = new Map(metadataRef.current);
+    try {
+      validationSchema.validateSync(state, { abortEarly: false });
+    } catch (err) {
+      hasError = true;
+      if (err.inner) {
+        err.inner.forEach((validationError) => {
+          const yupPath = validationError.path;
+          const dotPath = yupPath.replace(/\[(\d+)\]/g, ".$1");
+          const parts = dotPath.split(".");
+          let current = state;
+          const compositeParts = [];
+          for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (Array.isArray(current)) {
+              const index = parseInt(part, 10);
+              const item = current[index];
+              if (item && typeof item === "object") {
+                const genericPath = compositeParts.join(".").replace(/\.\d+/g, "");
+                const idKey = arrayIdentifiers?.[genericPath] || "id";
+                const id = item[idKey];
+                compositeParts.push(String(id !== void 0 ? id : index));
+              } else {
+                compositeParts.push(part);
+              }
+              current = item;
+            } else {
+              compositeParts.push(part);
+              current = current?.[part];
+            }
+          }
+          const compositeKey = compositeParts.join(".");
+          const currentMeta = newMetadata.get(compositeKey) || {
+            isTouched: false,
+            isInvalid: false,
+            errorMessage: ""
+          };
+          newMetadata.set(compositeKey, {
+            ...currentMeta,
+            isTouched: true,
+            isInvalid: true,
+            errorMessage: validationError.message
           });
-        }
-      } else {
-        const val = getNestedValue(stateRef.current, ruleKey);
-        const rule = typeof ruleVal === "function" ? ruleVal(val, stateRef.current) : ruleVal;
-        const msg = getMessage(ruleKey);
-        const err = performValidations(val, rule, msg);
-        nextErrors.set(ruleKey, err);
-        if (err.isInvalid) hasInvalid = true;
+        });
       }
-    };
-    Object.entries(rules).forEach(([k, v]) => processRule(k, v));
-    setErrors(nextErrors);
-    setTouched((prev) => {
-      const next = new Map(prev);
-      nextErrors.forEach((_, k) => next.set(k, true));
-      return next;
-    });
-    return hasInvalid;
-  }, [rules, getMessage, performValidations]);
+    }
+    setMetadata(newMetadata);
+    return hasError;
+  }, [validationSchema, state, arrayIdentifiers]);
   const handleFieldChange = useCallback(
     (resolution, newValue) => {
       if (!resolution) return;
@@ -443,17 +477,29 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
         parentId,
         nestedField
       } = resolution;
+      let finalValue = newValue;
+      let rule = getRule(fieldPath, validationSchema);
+      if (rule && rule.type === "array" && type === "primitiveArray" /* PrimitiveArray */ && rule.innerType) {
+        rule = rule.innerType;
+      }
+      if (rule && rule.type === "string") {
+        try {
+          finalValue = rule.cast(newValue);
+        } catch {
+        }
+      }
       setState((prev) => {
         if (type === "scalar" /* Scalar */) {
           return handleNestedChange({
             state: prev,
             id: compositeKey,
-            value: newValue
+            value: finalValue,
+            hasNestedValues: compositeKey.includes(".")
           });
         }
         if (type === "primitiveArray" /* PrimitiveArray */) {
           const arr = [...prev[arrayKey]];
-          arr[index] = newValue;
+          arr[index] = finalValue;
           return { ...prev, [arrayKey]: arr };
         }
         if (type === "objectArray" /* ObjectArray */) {
@@ -462,7 +508,7 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
             arrayKey,
             index,
             field: resolution.field,
-            value: newValue
+            value: finalValue
           });
         }
         if (type === "nestedPrimitiveArray" /* NestedPrimitiveArray */) {
@@ -471,41 +517,40 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
           const parentArr = [...prev[parentKey]];
           const pItem = { ...parentArr[pIndex] };
           const nestedArr = [...getNestedValue(pItem, nestedField) || []];
-          nestedArr[index] = newValue;
+          nestedArr[index] = finalValue;
           pItem[nestedField] = nestedArr;
-          const updatedItem = setNestedValue(pItem, nestedField, nestedArr);
-          parentArr[pIndex] = updatedItem;
+          parentArr[pIndex] = pItem;
           return { ...prev, [parentKey]: parentArr };
         }
         return prev;
       });
-      let extraContext = {};
-      if (type === "objectArray" /* ObjectArray */ || type === "nestedPrimitiveArray" /* NestedPrimitiveArray */) {
-        const idx = index;
-        const arrKey = arrayKey || parentKey;
-        extraContext = {
-          index: idx,
-          item: stateRef.current[arrKey]?.[idx]
-        };
-      }
-      validateField(compositeKey, fieldPath, newValue, extraContext);
+      validateField(compositeKey, fieldPath, finalValue);
     },
-    [getIndex, validateField]
+    [getIndex, validateField, getRule, validationSchema]
   );
   const createHandlers = useCallback(
     (resolution) => {
       if (!resolution) return {};
       const { compositeKey, fieldPath, value } = resolution;
-      const err = errorsRef.current.get(compositeKey);
-      const isTouched = touchedRef.current.get(compositeKey);
+      const meta = metadataRef.current.get(compositeKey);
+      const isTouched = meta?.isTouched;
       return {
         id: compositeKey,
-        isInvalid: Boolean(isTouched && err?.isInvalid),
-        errorMessage: isTouched ? err?.errorMessage || "" : "",
+        isInvalid: Boolean(isTouched && meta?.isInvalid),
+        errorMessage: isTouched ? meta?.errorMessage || "" : "",
         onBlur: () => {
-          if (touchedRef.current.get(compositeKey)) return;
+          if (metadataRef.current.get(compositeKey)?.isTouched) return;
           validateField(compositeKey, fieldPath, value);
-          setTouched((prev) => new Map(prev).set(compositeKey, true));
+          setMetadata((prev) => {
+            const newMap = new Map(prev);
+            const current = newMap.get(compositeKey) || {
+              isTouched: false,
+              isInvalid: false,
+              errorMessage: ""
+            };
+            newMap.set(compositeKey, { ...current, isTouched: true });
+            return newMap;
+          });
         }
       };
     },
@@ -587,8 +632,7 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
         });
         if (itemId !== void 0) {
           const prefix = `${String(arrayKey)}.${itemId}.`;
-          setTouched((prev) => removeCompositeKeysByPrefix(prev, prefix));
-          setErrors((prev) => removeCompositeKeysByPrefix(prev, prefix));
+          setMetadata((prev) => removeCompositeKeysByPrefix(prev, prefix));
         }
       },
       removeById: (arrayKey, itemId) => {
@@ -600,8 +644,7 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
             return { ...prev, [arrayKey]: arr };
           });
           const prefix = `${String(arrayKey)}.${itemId}.`;
-          setTouched((prev) => removeCompositeKeysByPrefix(prev, prefix));
-          setErrors((prev) => removeCompositeKeysByPrefix(prev, prefix));
+          setMetadata((prev) => removeCompositeKeysByPrefix(prev, prefix));
         }
       },
       updateItem: (arrayKey, index, value) => {
@@ -639,10 +682,22 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
     }),
     [getIndex, arrayIdentifiers]
   );
-  const onBlur = (id) => {
-    validateField(String(id), String(id), stateRef.current[id]);
-    setTouched((prev) => new Map(prev).set(String(id), true));
-  };
+  const onBlur = useCallback(
+    (id) => {
+      validateField(String(id), String(id), stateRef.current[id]);
+      setMetadata((prev) => {
+        const newMap = new Map(prev);
+        const current = newMap.get(String(id)) || {
+          isTouched: false,
+          isInvalid: false,
+          errorMessage: ""
+        };
+        newMap.set(String(id), { ...current, isTouched: true });
+        return newMap;
+      });
+    },
+    [validateField]
+  );
   const polymorphicOnValueChange = useCallback(
     (...args) => {
       const value = args[args.length - 1];
@@ -665,48 +720,71 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
     },
     [validateField]
   );
-  return {
-    state,
-    setState,
-    touched,
-    errors: errors2,
-    on,
-    helpers,
-    onBlur,
-    onValueChange: polymorphicOnValueChange,
-    onSelectionChange: polymorphicOnSelectionChange,
-    isDirty: touched.size > 0,
-    hasInvalidValues: validateAll,
-    resetForm: (preservedKeys) => {
-      if (preservedKeys && preservedKeys.length > 0) {
-        const nextState = { ...initialState };
-        preservedKeys.forEach((k) => {
-          if (stateRef.current[k] !== void 0)
-            nextState[k] = stateRef.current[k];
-        });
-        setState(nextState);
-      } else {
-        setState(initialState);
-      }
-      setTouched(/* @__PURE__ */ new Map());
-      setErrors(/* @__PURE__ */ new Map());
+  const onSubmit = useCallback(
+    (fn) => (e) => {
+      e.preventDefault();
+      if (validateAll()) return;
+      fn(stateRef.current, e);
     },
-    resetTouched: (preservedKeys) => {
-      if (preservedKeys && preservedKeys.length > 0) {
-        setTouched((prev) => {
-          const next = /* @__PURE__ */ new Map();
-          for (const [k, v] of prev.entries()) {
-            if (preservedKeys.some((pk) => k.startsWith(String(pk)))) {
-              next.set(k, v);
-            }
-          }
-          return next;
-        });
-      } else {
-        setTouched(/* @__PURE__ */ new Map());
-      }
-    }
-  };
+    [validateAll]
+  );
+  return useMemo(
+    () => ({
+      state,
+      setState,
+      metadata,
+      on,
+      helpers,
+      onFieldChange: polymorphicOnValueChange,
+      onFieldBlur: onBlur,
+      onSelectionChange: polymorphicOnSelectionChange,
+      isDirty: Array.from(metadata.values()).some((m) => m.isTouched),
+      reset: (options) => {
+        const { preservedStateKeys, preserveTouched } = options || {};
+        if (preservedStateKeys && preservedStateKeys.length > 0) {
+          const nextState = { ...initialState };
+          preservedStateKeys.forEach((k) => {
+            if (stateRef.current[k] !== void 0)
+              nextState[k] = stateRef.current[k];
+          });
+          setState(nextState);
+        } else {
+          setState(initialState);
+        }
+        if (preserveTouched) {
+          setMetadata((prev) => {
+            const next = /* @__PURE__ */ new Map();
+            prev.forEach((v, k) => {
+              if (v.isTouched) {
+                next.set(k, {
+                  isTouched: true,
+                  isInvalid: false,
+                  errorMessage: ""
+                });
+              }
+            });
+            return next;
+          });
+        } else {
+          setMetadata(/* @__PURE__ */ new Map());
+        }
+      },
+      onSubmit
+    }),
+    [
+      state,
+      setState,
+      metadata,
+      on,
+      helpers,
+      onBlur,
+      polymorphicOnValueChange,
+      polymorphicOnSelectionChange,
+      validateAll,
+      onSubmit,
+      initialState
+    ]
+  );
 }
 export {
   NextUIError,