@juantroconisf/lib 7.0.0 → 9.0.0

package/dist/index.mjs

@@ -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,11 +19,15 @@ 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];
-    current[key] = { ...current[key] };
+    if (Array.isArray(current[key])) {
+      current[key] = [...current[key]];
+    } else {
+      current[key] = { ...current[key] };
+    }
     current = current[key];
   }
   current[propertyDepth[propertyDepth.length - 1]] = value;
@@ -51,7 +48,11 @@ function handleArrayItemChange({
   } else {
     let current = item;
     for (let i = 0; i < fieldDepth.length - 1; i++) {
-      current[fieldDepth[i]] = { ...current[fieldDepth[i]] };
+      if (Array.isArray(current[fieldDepth[i]])) {
+        current[fieldDepth[i]] = [...current[fieldDepth[i]]];
+      } else {
+        current[fieldDepth[i]] = { ...current[fieldDepth[i]] };
+      }
       current = current[fieldDepth[i]];
     }
     current[fieldDepth[fieldDepth.length - 1]] = value;
@@ -62,141 +63,134 @@ 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/useForm.tsx
+import { Form } from "@heroui/react";
+
+// 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
@@ -240,7 +234,7 @@ function resolveFieldData(args, state, getIndex, getNestedValue2) {
     }
     const arrayKey = arg0;
     const index = arg1;
-    const arr = state[arrayKey];
+    const arr = getNestedValue2(state, arrayKey);
     return {
       type: "primitiveArray" /* PrimitiveArray */,
       compositeKey: `${arrayKey}.@${index}`,
@@ -294,19 +288,42 @@ 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";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_OPTIONS = {};
+function useForm(schema, {
+  arrayIdentifiers,
+  onFormSubmit: onFormSubmitProp,
+  resetOnSubmit = false,
+  keepValues: keepValuesProp
+} = DEFAULT_OPTIONS) {
+  const { initialState, validationSchema } = useMemo(() => {
+    const state2 = {};
+    const extractedRules = {};
+    Object.entries(schema).forEach(([key, value]) => {
+      if (isSchema(value)) {
+        try {
+          state2[key] = value.cast(void 0);
+        } 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 +339,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 +348,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);
-      }
-      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+/, ""));
+    (compositeKey, fieldPath, value) => {
+      let schemaRule = getRule(fieldPath, validationSchema);
+      if (schemaRule) {
+        if (runValidation(schemaRule, value, compositeKey)) return true;
       }
-      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,18 +494,33 @@ 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;
-          return { ...prev, [arrayKey]: arr };
+          return handleNestedChange({
+            state: prev,
+            id: `${arrayKey}.${index}`,
+            value: finalValue,
+            hasNestedValues: true
+          });
         }
         if (type === "objectArray" /* ObjectArray */) {
           return handleArrayItemChange({
@@ -462,7 +528,7 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
             arrayKey,
             index,
             field: resolution.field,
-            value: newValue
+            value: finalValue
           });
         }
         if (type === "nestedPrimitiveArray" /* NestedPrimitiveArray */) {
@@ -471,41 +537,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;
+          });
         }
       };
     },
@@ -569,54 +634,77 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
     () => ({
       addItem: (arrayKey, item, index) => {
         setState((prev) => {
-          const arr = [...prev[arrayKey]];
+          const arr = [...getNestedValue(prev, arrayKey) || []];
           if (index === void 0) arr.push(item);
           else arr.splice(index, 0, item);
-          return { ...prev, [arrayKey]: arr };
+          return handleNestedChange({
+            state: prev,
+            id: arrayKey,
+            value: arr,
+            hasNestedValues: String(arrayKey).includes(".")
+          });
         });
       },
       removeItem: (arrayKey, index) => {
-        const currentArr = stateRef.current[arrayKey];
+        const currentArr = getNestedValue(stateRef.current, arrayKey) || [];
         const item = currentArr[index];
         const idKey = arrayIdentifiers?.[arrayKey] || "id";
         const itemId = item?.[idKey];
         setState((prev) => {
-          const arr = [...prev[arrayKey]];
+          const arr = [...getNestedValue(prev, arrayKey) || []];
           arr.splice(index, 1);
-          return { ...prev, [arrayKey]: arr };
+          return handleNestedChange({
+            state: prev,
+            id: arrayKey,
+            value: arr,
+            hasNestedValues: String(arrayKey).includes(".")
+          });
         });
         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) => {
         const index = getIndex(arrayKey, itemId);
         if (index !== void 0) {
           setState((prev) => {
-            const arr = [...prev[arrayKey]];
+            const arr = [...getNestedValue(prev, arrayKey) || []];
             arr.splice(index, 1);
-            return { ...prev, [arrayKey]: arr };
+            return handleNestedChange({
+              state: prev,
+              id: arrayKey,
+              value: arr,
+              hasNestedValues: String(arrayKey).includes(".")
+            });
           });
           const prefix = `${String(arrayKey)}.${itemId}.`;
-          setTouched((prev) => removeCompositeKeysByPrefix(prev, prefix));
-          setErrors((prev) => removeCompositeKeysByPrefix(prev, prefix));
+          setMetadata((prev) => removeCompositeKeysByPrefix(prev, prefix));
         }
       },
       updateItem: (arrayKey, index, value) => {
         setState((prev) => {
-          const arr = [...prev[arrayKey]];
+          const arr = [...getNestedValue(prev, arrayKey) || []];
           arr[index] = value;
-          return { ...prev, [arrayKey]: arr };
+          return handleNestedChange({
+            state: prev,
+            id: arrayKey,
+            value: arr,
+            hasNestedValues: String(arrayKey).includes(".")
+          });
         });
       },
       moveItem: (arrayKey, from, to) => {
         setState((prev) => {
-          const arr = [...prev[arrayKey]];
+          const arr = [...getNestedValue(prev, arrayKey) || []];
           const [item] = arr.splice(from, 1);
           arr.splice(to, 0, item);
-          return { ...prev, [arrayKey]: arr };
+          return handleNestedChange({
+            state: prev,
+            id: arrayKey,
+            value: arr,
+            hasNestedValues: String(arrayKey).includes(".")
+          });
         });
       },
       moveById: (arrayKey, fromId, toId) => {
@@ -624,25 +712,42 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
         const toIndex = getIndex(arrayKey, toId);
         if (fromIndex !== void 0 && toIndex !== void 0) {
           setState((prev) => {
-            const arr = [...prev[arrayKey]];
+            const arr = [...getNestedValue(prev, arrayKey) || []];
             const [item] = arr.splice(fromIndex, 1);
             arr.splice(toIndex, 0, item);
-            return { ...prev, [arrayKey]: arr };
+            return handleNestedChange({
+              state: prev,
+              id: arrayKey,
+              value: arr,
+              hasNestedValues: String(arrayKey).includes(".")
+            });
           });
         }
       },
       getItem: (arrayKey, itemId) => {
         const index = getIndex(arrayKey, itemId);
         if (index === void 0) return void 0;
-        return stateRef.current[arrayKey][index];
+        return getNestedValue(stateRef.current, arrayKey)[index];
       }
     }),
     [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,22 +770,26 @@ 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 onFormSubmit = useCallback(
+    (fn) => (e) => {
+      e.preventDefault();
+      if (validateAll()) return;
+      fn(stateRef.current, e);
+    },
+    [validateAll]
+  );
+  const onFormSubmitPropRef = useRef(onFormSubmitProp);
+  onFormSubmitPropRef.current = onFormSubmitProp;
+  const resetOnSubmitRef = useRef(resetOnSubmit);
+  resetOnSubmitRef.current = resetOnSubmit;
+  const keepValuesPropRef = useRef(keepValuesProp);
+  keepValuesPropRef.current = keepValuesProp;
+  const handleReset = useCallback(
+    (options) => {
+      const { keepValues } = options || {};
+      if (keepValues && keepValues.length > 0) {
         const nextState = { ...initialState };
-        preservedKeys.forEach((k) => {
+        keepValues.forEach((k) => {
           if (stateRef.current[k] !== void 0)
             nextState[k] = stateRef.current[k];
         });
@@ -688,25 +797,59 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
       } else {
         setState(initialState);
       }
-      setTouched(/* @__PURE__ */ new Map());
-      setErrors(/* @__PURE__ */ new Map());
+      setMetadata(/* @__PURE__ */ new Map());
     },
-    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());
-      }
-    }
-  };
+    [initialState]
+  );
+  const validateAllRef = useRef(validateAll);
+  validateAllRef.current = validateAll;
+  const ControlledForm = useMemo(() => {
+    return (props) => {
+      const { onSubmit, ...rest } = props;
+      const handleSubmit = (e) => {
+        e.preventDefault();
+        if (validateAllRef.current()) {
+          return;
+        }
+        onFormSubmitPropRef.current?.(stateRef.current, e);
+        if (resetOnSubmitRef.current) {
+          handleReset({ keepValues: keepValuesPropRef.current });
+        }
+        onSubmit?.(stateRef.current, e);
+      };
+      return /* @__PURE__ */ jsx(Form, { onSubmit: handleSubmit, ...rest });
+    };
+  }, []);
+  return useMemo(
+    () => ({
+      state,
+      setState,
+      metadata,
+      on,
+      helpers,
+      onFieldChange: polymorphicOnValueChange,
+      onFieldBlur: onBlur,
+      onSelectionChange: polymorphicOnSelectionChange,
+      isDirty: Array.from(metadata.values()).some((m) => m.isTouched),
+      onFormReset: handleReset,
+      onFormSubmit,
+      ControlledForm
+    }),
+    [
+      state,
+      setState,
+      metadata,
+      on,
+      helpers,
+      onBlur,
+      polymorphicOnValueChange,
+      polymorphicOnSelectionChange,
+      validateAll,
+      onFormSubmit,
+      ControlledForm,
+      initialState
+    ]
+  );
 }
 export {
   NextUIError,