@juantroconisf/lib 6.1.0 → 8.0.0

package/dist/index.js

@@ -35,7 +35,7 @@ var NextUIError = class {
 };
 
 // src/hooks/useForm.tsx
-var import_react = require("react");
+var import_react2 = require("react");
 
 // src/utils/utils.ts
 function handleNestedChange({
@@ -45,7 +45,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];
@@ -81,667 +81,576 @@ 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
+var import_yup = require("yup");
+var import_react = require("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]
-  };
+  (0, import_react.useEffect)(() => {
+    const locale = getClientCookie() || "en";
+    if (translations[locale]) {
+      (0, import_yup.setLocale)(translations[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]
+// src/hooks/useForm.utils.ts
+function resolveFieldData(args, state, getIndex, getNestedValue2) {
+  const argCount = args.length;
+  if (argCount === 1) {
+    const id = args[0];
+    return {
+      type: "scalar" /* Scalar */,
+      compositeKey: id,
+      fieldPath: id,
+      value: getNestedValue2(state, id),
+      id
+    };
+  }
+  if (argCount === 2) {
+    const [arg0, arg1] = args;
+    if (typeof arg0 === "string" && arg0.includes(".")) {
+      const parts = arg0.split(".");
+      const arrayKey2 = parts[0];
+      if (Array.isArray(state[arrayKey2])) {
+        const field = parts.slice(1).join(".");
+        const itemId = arg1;
+        const index2 = getIndex(arrayKey2, itemId);
+        if (index2 === void 0) return null;
+        const arr2 = state[arrayKey2];
+        const item = arr2[index2];
+        const value = getNestedValue2(item, field);
+        return {
+          type: "objectArray" /* ObjectArray */,
+          compositeKey: `${arrayKey2}.${itemId}.${field}`,
+          fieldPath: arg0,
+          // "array.field"
+          value,
+          arrayKey: arrayKey2,
+          itemId,
+          field,
+          index: index2
         };
-        break;
       }
     }
-    return errorFound;
-  };
-  return { performValidations };
+    const arrayKey = arg0;
+    const index = arg1;
+    const arr = state[arrayKey];
+    return {
+      type: "primitiveArray" /* PrimitiveArray */,
+      compositeKey: `${arrayKey}.@${index}`,
+      fieldPath: `${arrayKey}`,
+      value: arr?.[index],
+      arrayKey,
+      index
+    };
+  }
+  if (argCount === 3) {
+    const [arrayKey, itemId, field] = args;
+    const index = getIndex(arrayKey, itemId);
+    if (index === void 0) return null;
+    const arr = state[arrayKey];
+    const item = arr[index];
+    const value = getNestedValue2(item, field);
+    return {
+      type: "objectArray" /* ObjectArray */,
+      compositeKey: `${arrayKey}.${itemId}.${field}`,
+      fieldPath: `${arrayKey}.${field}`,
+      // Normalized path for rules
+      value,
+      arrayKey,
+      itemId,
+      field,
+      index
+    };
+  }
+  if (argCount === 4) {
+    const [parentKey, parentId, field, index] = args;
+    const parentIndex = getIndex(parentKey, parentId);
+    if (parentIndex === void 0) return null;
+    const arr = state[parentKey];
+    const item = arr[parentIndex];
+    const nestedArr = getNestedValue2(item, field);
+    const value = Array.isArray(nestedArr) ? nestedArr[index] : void 0;
+    return {
+      type: "nestedPrimitiveArray" /* NestedPrimitiveArray */,
+      compositeKey: `${parentKey}.${parentId}.${field}.@${index}`,
+      fieldPath: `${parentKey}.${field}`,
+      // Roughly?
+      value,
+      parentKey,
+      parentId,
+      field,
+      index,
+      nestedField: field
+    };
+  }
+  return null;
 }
 
 // src/hooks/useForm.tsx
-function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
-  const [state, setState] = (0, import_react.useState)(initialState), [touched, setTouched] = (0, import_react.useState)(/* @__PURE__ */ new Map()), [errors2, setErrors] = (0, import_react.useState)(/* @__PURE__ */ new Map()), { performValidations } = useValidate();
-  const indexMap = (0, import_react.useMemo)(() => {
-    const map2 = /* @__PURE__ */ new Map();
-    for (const key in state) {
-      if (Array.isArray(state[key])) {
+var import_yup2 = require("yup");
+var DEFAULT_OPTIONS = {};
+function useForm(schema, { arrayIdentifiers } = DEFAULT_OPTIONS) {
+  const { initialState, validationSchema } = (0, import_react2.useMemo)(() => {
+    const state2 = {};
+    const extractedRules = {};
+    Object.entries(schema).forEach(([key, value]) => {
+      if ((0, import_yup2.isSchema)(value)) {
+        try {
+          state2[key] = value.getDefault();
+        } catch {
+          state2[key] = void 0;
+        }
+        extractedRules[key] = value;
+      } else {
+        state2[key] = value;
+      }
+    });
+    return {
+      initialState: state2,
+      validationSchema: (0, import_yup2.object)().shape(extractedRules)
+    };
+  }, [schema]);
+  const [state, setState] = (0, import_react2.useState)(initialState), [metadata, setMetadata] = (0, import_react2.useState)(/* @__PURE__ */ new Map());
+  useComponentLanguage();
+  const stateRef = (0, import_react2.useRef)(state), metadataRef = (0, import_react2.useRef)(metadata);
+  stateRef.current = state;
+  metadataRef.current = metadata;
+  const indexMap = (0, import_react2.useMemo)(() => {
+    const map = /* @__PURE__ */ new Map();
+    const traverse = (current, path) => {
+      if (!current || typeof current !== "object") return;
+      if (Array.isArray(current)) {
         const itemMap = /* @__PURE__ */ new Map();
-        const idKey = arrayIdentifiers?.[key] || "id";
-        state[key].forEach((item, index) => {
+        const genericPath = path.replace(/\.\d+/g, "");
+        const idKey = arrayIdentifiers?.[genericPath] || "id";
+        current.forEach((item, index) => {
           if (item && typeof item === "object") {
             const idValue = item[idKey];
             if (idValue !== void 0) {
               itemMap.set(idValue, index);
             }
+            traverse(item, `${path}.${index}`);
           }
         });
-        map2.set(key, itemMap);
+        map.set(path, itemMap);
+      } else {
+        Object.keys(current).forEach((key) => {
+          const nextPath = path ? `${path}.${key}` : key;
+          traverse(current[key], nextPath);
+        });
       }
-    }
-    return map2;
+    };
+    traverse(state, "");
+    return map;
   }, [state, arrayIdentifiers]);
-  const getIndex = (0, import_react.useCallback)(
-    (arrayKey, itemId) => {
-      return indexMap.get(arrayKey)?.get(itemId);
-    },
-    [indexMap]
-  );
-  const getRule = (path) => {
-    if (rules?.[path]) return rules[path];
-    const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
-    return rules?.[genericPath];
-  };
-  const getMessage = (path) => {
-    if (messages?.[path]) return messages[path];
-    const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
-    return messages?.[genericPath];
-  };
-  const validateInput = (compositeKey, value, ruleKey) => {
-    const ruleDef = getRule(ruleKey);
-    const rule = typeof ruleDef === "function" ? ruleDef(value, state) : ruleDef;
-    const message = getMessage(ruleKey);
-    const error = performValidations(value, rule, message);
-    setErrors((prev) => new Map(prev).set(compositeKey, error));
-  };
-  const getUXProps = (0, import_react.useCallback)(
-    (compositeKey) => {
-      const inputError = errors2.get(compositeKey);
-      const isTouched = touched.get(compositeKey);
-      return {
-        isInvalid: Boolean(isTouched && inputError?.isInvalid),
-        errorMessage: isTouched ? inputError?.errorMessage || "" : ""
-      };
-    },
-    [errors2, touched]
-  );
-  const onBlur = (id) => {
-    validateInput(String(id), state[id], String(id));
-    if (touched.get(String(id))) return;
-    setTouched((prev) => new Map(prev).set(String(id), true));
-  }, onValueChange = ((...args) => {
-    if (args.length === 2) {
-      const [id, value] = args;
-      setState((prev) => handleNestedChange({ state: prev, id, value }));
-      validateInput(String(id), value, String(id));
-      return;
-    }
-    if (args.length === 3) {
-      const [arrayKey, index, value] = args;
-      setState((prev) => {
-        const arr = [...prev[arrayKey]];
-        arr[index] = value;
-        return { ...prev, [arrayKey]: arr };
-      });
-      return;
-    }
-    if (args.length === 4) {
-      const [arrayKey, itemId, field, value] = args;
-      const index = getIndex(String(arrayKey), itemId);
-      if (index === void 0) return;
-      setState(
-        (prev) => handleArrayItemChange({ state: prev, arrayKey, index, field, value })
-      );
-      validateItemInput(arrayKey, itemId, field, value);
-      return;
+  const indexMapRef = (0, import_react2.useRef)(indexMap);
+  indexMapRef.current = indexMap;
+  const getIndex = (0, import_react2.useCallback)((arrayKey, itemId) => {
+    return indexMapRef.current.get(arrayKey)?.get(itemId);
+  }, []);
+  const ruleCache = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  (0, import_react2.useMemo)(() => {
+    ruleCache.current.clear();
+  }, [validationSchema]);
+  const getRule = (0, import_react2.useCallback)((path, schema2) => {
+    if (ruleCache.current.has(path)) {
+      return ruleCache.current.get(path);
     }
-    if (args.length === 5) {
-      const [parentKey, parentId, field, index, value] = args;
-      const parentIndex = getIndex(String(parentKey), parentId);
-      if (parentIndex === void 0) return;
-      setState((prev) => {
-        const parentArr = [...prev[parentKey]];
-        const item = { ...parentArr[parentIndex] };
-        const nestedArr = [...getNestedValue(item, field) || []];
-        nestedArr[index] = value;
-        const updatedItem = setNestedValue(item, field, nestedArr);
-        parentArr[parentIndex] = updatedItem;
-        return { ...prev, [parentKey]: parentArr };
-      });
-      return;
+    let rule;
+    try {
+      rule = (0, import_yup2.reach)(schema2, path);
+    } catch {
+      const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
+      try {
+        rule = (0, import_yup2.reach)(schema2, genericPath);
+      } catch {
+        rule = void 0;
+      }
     }
-  }), onSelectionChange = (id, value) => {
-    const fixedValue = typeof value === "string" || value === null ? value : Array.from(value);
-    setState(
-      (prev) => handleNestedChange({
-        state: prev,
-        id,
-        value: fixedValue
-      })
-    );
-    validateInput(String(id), fixedValue, String(id));
-  };
-  const getItemCompositeKey = (arrayKey, itemId, field) => `${arrayKey}.${itemId}.${field}`;
-  const getPrimitiveCompositeKey = (arrayKey, index) => `${arrayKey}.@${index}`;
-  const getNestedPrimitiveCompositeKey = (parentKey, parentId, field, index) => `${parentKey}.${parentId}.${field}.@${index}`;
-  const validateItemInput = (arrayKey, itemId, field, value) => {
-    const index = getIndex(String(arrayKey), itemId);
-    if (index === void 0) return;
-    const item = state[arrayKey][index];
-    const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
-    let genericField = field.replace(/\.@\d+/, "");
-    if (genericField === "")
-      genericField = String(arrayKey);
-    else genericField = `${String(arrayKey)}.${genericField}`;
-    let effectivePath = `${String(arrayKey)}.${field}`;
-    if (field === "") effectivePath = String(arrayKey);
-    effectivePath = effectivePath.replace(/\.@\d+/g, "").replace(/\.@\d+$/, "");
-    const ruleDef = getRule(effectivePath);
-    const rule = typeof ruleDef === "function" ? ruleDef(value, state, item, index) : ruleDef;
-    const message = getMessage(effectivePath);
-    setErrors(
-      (prev) => new Map(prev).set(compositeKey, performValidations(value, rule, message))
-    );
-  };
-  const getItemUXProps = (0, import_react.useCallback)(
-    (arrayKey, itemId, field) => {
-      const compositeKey = getItemCompositeKey(arrayKey, itemId, field);
-      const inputError = errors2.get(compositeKey);
-      const isTouched = touched.get(compositeKey);
-      return {
-        isInvalid: Boolean(isTouched && inputError?.isInvalid),
-        errorMessage: isTouched ? inputError?.errorMessage || "" : ""
-      };
-    },
-    [errors2, touched]
-  );
-  const onItemBlur = (arrayKey, itemId, field) => {
-    const index = getIndex(String(arrayKey), itemId);
-    if (index === void 0) return;
-    const arr = state[arrayKey];
-    const value = getNestedValue(arr[index], field);
-    validateItemInput(arrayKey, itemId, field, value);
-    const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
-    if (touched.get(compositeKey)) return;
-    setTouched((prev) => new Map(prev).set(compositeKey, true));
-  };
-  const onItemValueChange = (arrayKey, itemId, field, value) => {
-    const index = getIndex(String(arrayKey), itemId);
-    if (index === void 0) return;
-    setState(
-      (prev) => handleArrayItemChange({ state: prev, arrayKey, index, field, value })
-    );
-    validateItemInput(arrayKey, itemId, field, value);
-  };
-  const onItemSelectionChange = (arrayKey, itemId, field, value) => {
-    const index = getIndex(String(arrayKey), itemId);
-    if (index === void 0) return;
-    const arr = state[arrayKey];
-    const currentVal = getNestedValue(arr[index], field);
-    const isString = typeof currentVal === "string" || currentVal === null;
-    const fixedValue = typeof value === "string" || value === null ? value : isString ? Array.from(value)[0] || null : Array.from(value);
-    setState(
-      (prev) => handleArrayItemChange({
-        state: prev,
-        arrayKey,
-        index,
-        field,
-        value: fixedValue
-      })
-    );
-    validateItemInput(arrayKey, itemId, field, fixedValue);
-  };
-  const validateNestedInput = (dotPath, value) => {
-    const ruleDef = getRule(dotPath);
-    const rule = typeof ruleDef === "function" ? ruleDef(value, state) : ruleDef;
-    const message = getMessage(dotPath);
-    setErrors(
-      (prev) => new Map(prev).set(dotPath, performValidations(value, rule, message))
-    );
-  };
-  const onNestedBlur = (dotPath) => {
-    const value = getNestedValue(state, dotPath);
-    validateNestedInput(dotPath, value);
-    if (touched.get(dotPath)) return;
-    setTouched((prev) => new Map(prev).set(dotPath, true));
-  };
-  const onNestedValueChange = (dotPath, value) => {
-    setState((prev) => setNestedValue(prev, dotPath, value));
-    validateNestedInput(dotPath, value);
-  };
-  const onNestedSelectionChange = (dotPath, value) => {
-    const currentVal = getNestedValue(state, dotPath);
-    const isString = typeof currentVal === "string" || currentVal === null;
-    const fixedValue = typeof value === "string" || value === null ? value : isString ? Array.from(value)[0] || null : Array.from(value);
-    setState((prev) => setNestedValue(prev, dotPath, fixedValue));
-    validateNestedInput(dotPath, fixedValue);
-  };
-  const on = {
-    input: (...args) => {
-      if (args.length === 1) {
-        const id = args[0];
-        const key = String(id);
-        const isTopLevel = key in state;
-        if (isTopLevel) {
-          return {
-            ...getUXProps(key),
-            id: key,
-            onBlur: () => onBlur(id),
-            onValueChange: (v) => onValueChange(id, v),
-            value: state[id]
+    ruleCache.current.set(path, rule);
+    return rule;
+  }, []);
+  const runValidation = (0, import_react2.useCallback)(
+    (ruleDef, value, compositeKey) => {
+      if ((0, import_yup2.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 {
-          ...getUXProps(key),
-          id: key,
-          onBlur: () => onNestedBlur(key),
-          onValueChange: (v) => onNestedValueChange(key, v),
-          value: getNestedValue(state, key)
-        };
       }
-      if (args.length === 2) {
-        const [arrayKey2, index2] = args;
-        const arr2 = state[arrayKey2];
-        const value2 = arr2?.[index2];
-        const compositeKey2 = getPrimitiveCompositeKey(String(arrayKey2), index2);
-        return {
-          ...getItemUXProps(String(arrayKey2), `@${index2}`, ""),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
-          onValueChange: (v) => {
-            setState((prev) => {
-              const arr3 = [...prev[arrayKey2]];
-              arr3[index2] = v;
-              return { ...prev, [arrayKey2]: arr3 };
-            });
-            validateItemInput(arrayKey2, `@${index2}`, "", v);
-          },
-          value: value2
-        };
+      return false;
+    },
+    []
+  );
+  const validateField = (0, import_react2.useCallback)(
+    (compositeKey, fieldPath, value) => {
+      let schemaRule = getRule(fieldPath, validationSchema);
+      if (schemaRule) {
+        if (runValidation(schemaRule, value, compositeKey)) return true;
       }
-      if (args.length === 4) {
-        const [parentKey, parentId, field2, index2] = args;
-        const parentIndex = getIndex(String(parentKey), parentId);
-        const arr2 = state[parentKey];
-        const nestedArr = parentIndex !== void 0 ? getNestedValue(arr2[parentIndex], field2) : void 0;
-        const value2 = Array.isArray(nestedArr) ? nestedArr[index2] : void 0;
-        const compositeKey2 = getNestedPrimitiveCompositeKey(
-          String(parentKey),
-          parentId,
-          field2,
-          index2
-        );
-        return {
-          ...getItemUXProps(String(parentKey), parentId, `${field2}.@${index2}`),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
-          onValueChange: (v) => {
-            if (parentIndex === void 0) return;
-            setState((prev) => {
-              const parentArr = [...prev[parentKey]];
-              const item = { ...parentArr[parentIndex] };
-              const nestedArr2 = [...getNestedValue(item, field2) || []];
-              nestedArr2[index2] = v;
-              parentArr[parentIndex] = setNestedValue(item, field2, nestedArr2);
-              return { ...prev, [parentKey]: parentArr };
-            });
-            const fieldPath = `${field2}.@${index2}`;
-            validateItemInput(parentKey, parentId, fieldPath, v);
-          },
-          value: value2
+      setMetadata((prev) => {
+        const newMap = new Map(prev);
+        const currentMeta = newMap.get(compositeKey) || {
+          isTouched: false,
+          isInvalid: false,
+          errorMessage: ""
         };
-      }
-      const [arrayKey, itemId, field] = args;
-      const index = getIndex(String(arrayKey), itemId);
-      const arr = state[arrayKey];
-      const value = index !== void 0 ? getNestedValue(arr[index], field) : void 0;
-      const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
-      return {
-        ...getItemUXProps(String(arrayKey), itemId, field),
-        id: compositeKey,
-        onBlur: () => onItemBlur(arrayKey, itemId, field),
-        onValueChange: (v) => onItemValueChange(arrayKey, itemId, field, v),
-        value
-      };
+        newMap.set(compositeKey, {
+          ...currentMeta,
+          isInvalid: false,
+          errorMessage: ""
+        });
+        return newMap;
+      });
+      return false;
     },
-    select: (...args) => {
-      if (args.length === 1) {
-        const id = args[0];
-        const key = String(id);
-        const isTopLevel = key in state;
-        if (isTopLevel) {
-          const isString3 = typeof state[id] === "string" || state[id] === null;
-          return {
-            ...getUXProps(key),
-            id: key,
-            onBlur: () => onBlur(id),
-            onSelectionChange: (v) => onSelectionChange(
-              id,
-              !isString3 ? v : Array.from(v)[0] || null
-            ),
-            selectedKeys: state[id] === null ? [] : isString3 ? [state[id]] : state[id]
+    [getRule, runValidation, validationSchema]
+  );
+  const validateAll = (0, import_react2.useCallback)(() => {
+    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: ""
           };
-        }
-        const value2 = getNestedValue(state, key);
-        const isString2 = typeof value2 === "string" || value2 === null;
-        return {
-          ...getUXProps(key),
-          id: key,
-          onBlur: () => onNestedBlur(key),
-          onSelectionChange: (v) => onNestedSelectionChange(key, v),
-          selectedKeys: value2 === null ? [] : isString2 ? [value2] : value2
-        };
+          newMetadata.set(compositeKey, {
+            ...currentMeta,
+            isTouched: true,
+            isInvalid: true,
+            errorMessage: validationError.message
+          });
+        });
       }
-      if (args.length === 2) {
-        const [arrayKey2, index2] = args;
-        const arr2 = state[arrayKey2];
-        const value2 = arr2?.[index2];
-        const compositeKey2 = getPrimitiveCompositeKey(String(arrayKey2), index2);
-        return {
-          ...getItemUXProps(String(arrayKey2), `@${index2}`, ""),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
-          onSelectionChange: (v) => {
-            const fixedValue = typeof v === "string" || v === null ? v : Array.from(v)[0] || null;
-            setState((prev) => {
-              const arr3 = [...prev[arrayKey2]];
-              arr3[index2] = fixedValue;
-              return { ...prev, [arrayKey2]: arr3 };
-            });
-            validateItemInput(arrayKey2, `@${index2}`, "", fixedValue);
-          },
-          selectedKeys: value2 === null ? [] : [value2]
-        };
+    }
+    setMetadata(newMetadata);
+    return hasError;
+  }, [validationSchema, state, arrayIdentifiers]);
+  const handleFieldChange = (0, import_react2.useCallback)(
+    (resolution, newValue) => {
+      if (!resolution) return;
+      const {
+        type,
+        compositeKey,
+        fieldPath,
+        arrayKey,
+        index,
+        parentKey,
+        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 (args.length === 4) {
-        const [parentKey, parentId, field2, index2] = args;
-        const parentIndex = getIndex(String(parentKey), parentId);
-        const arr2 = state[parentKey];
-        const nestedArr = parentIndex !== void 0 ? getNestedValue(arr2[parentIndex], field2) : void 0;
-        const value2 = Array.isArray(nestedArr) ? nestedArr[index2] : null;
-        const compositeKey2 = getNestedPrimitiveCompositeKey(
-          String(parentKey),
-          parentId,
-          field2,
-          index2
-        );
-        return {
-          ...getItemUXProps(String(parentKey), parentId, `${field2}.@${index2}`),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
-          onSelectionChange: (v) => {
-            if (parentIndex === void 0) return;
-            const fixedValue = typeof v === "string" || v === null ? v : Array.from(v)[0] || null;
-            setState((prev) => {
-              const parentArr = [...prev[parentKey]];
-              const item = { ...parentArr[parentIndex] };
-              const nestedArr2 = [...getNestedValue(item, field2) || []];
-              nestedArr2[index2] = fixedValue;
-              parentArr[parentIndex] = setNestedValue(item, field2, nestedArr2);
-              return { ...prev, [parentKey]: parentArr };
-            });
-            const fieldPath = `${field2}.@${index2}`;
-            validateItemInput(parentKey, parentId, fieldPath, fixedValue);
-          },
-          selectedKeys: value2 === null ? [] : [value2]
-        };
+      if (rule && rule.type === "string") {
+        try {
+          finalValue = rule.cast(newValue);
+        } catch {
+        }
       }
-      const [arrayKey, itemId, field] = args;
-      const index = getIndex(String(arrayKey), itemId);
-      const arr = state[arrayKey];
-      const value = index !== void 0 ? getNestedValue(arr[index], field) : null;
-      const isString = typeof value === "string" || value === null;
-      const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
+      setState((prev) => {
+        if (type === "scalar" /* Scalar */) {
+          return handleNestedChange({
+            state: prev,
+            id: compositeKey,
+            value: finalValue,
+            hasNestedValues: compositeKey.includes(".")
+          });
+        }
+        if (type === "primitiveArray" /* PrimitiveArray */) {
+          const arr = [...prev[arrayKey]];
+          arr[index] = finalValue;
+          return { ...prev, [arrayKey]: arr };
+        }
+        if (type === "objectArray" /* ObjectArray */) {
+          return handleArrayItemChange({
+            state: prev,
+            arrayKey,
+            index,
+            field: resolution.field,
+            value: finalValue
+          });
+        }
+        if (type === "nestedPrimitiveArray" /* NestedPrimitiveArray */) {
+          const pIndex = getIndex(parentKey, parentId);
+          if (pIndex === void 0) return prev;
+          const parentArr = [...prev[parentKey]];
+          const pItem = { ...parentArr[pIndex] };
+          const nestedArr = [...getNestedValue(pItem, nestedField) || []];
+          nestedArr[index] = finalValue;
+          pItem[nestedField] = nestedArr;
+          parentArr[pIndex] = pItem;
+          return { ...prev, [parentKey]: parentArr };
+        }
+        return prev;
+      });
+      validateField(compositeKey, fieldPath, finalValue);
+    },
+    [getIndex, validateField, getRule, validationSchema]
+  );
+  const createHandlers = (0, import_react2.useCallback)(
+    (resolution) => {
+      if (!resolution) return {};
+      const { compositeKey, fieldPath, value } = resolution;
+      const meta = metadataRef.current.get(compositeKey);
+      const isTouched = meta?.isTouched;
       return {
-        ...getItemUXProps(String(arrayKey), itemId, field),
         id: compositeKey,
-        onBlur: () => onItemBlur(arrayKey, itemId, field),
-        onSelectionChange: (v) => onItemSelectionChange(arrayKey, itemId, field, v),
-        selectedKeys: value === null ? [] : isString ? [value] : value
+        isInvalid: Boolean(isTouched && meta?.isInvalid),
+        errorMessage: isTouched ? meta?.errorMessage || "" : "",
+        onBlur: () => {
+          if (metadataRef.current.get(compositeKey)?.isTouched) return;
+          validateField(compositeKey, fieldPath, value);
+          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;
+          });
+        }
       };
     },
-    autocomplete: (...args) => {
-      if (args.length === 1) {
-        const id = args[0];
-        const key = String(id);
-        const isTopLevel = key in state;
-        if (isTopLevel) {
-          return {
-            ...getUXProps(key),
-            id: key,
-            onBlur: () => onBlur(id),
-            onSelectionChange: (v) => onSelectionChange(id, v),
-            selectedKey: state[id]
-          };
-        }
+    [validateField]
+  );
+  const on = (0, import_react2.useMemo)(
+    () => ({
+      input: (...args) => {
+        const data = resolveFieldData(
+          args,
+          stateRef.current,
+          getIndex,
+          getNestedValue
+        );
+        if (!data) return {};
         return {
-          ...getUXProps(key),
-          id: key,
-          onBlur: () => onNestedBlur(key),
-          onSelectionChange: (v) => onNestedSelectionChange(key, v),
-          selectedKey: getNestedValue(state, key)
+          ...createHandlers(data),
+          value: data.value,
+          onValueChange: (v) => handleFieldChange(data, v)
         };
-      }
-      if (args.length === 2) {
-        const [arrayKey2, index2] = args;
-        const arr2 = state[arrayKey2];
-        const value2 = arr2?.[index2];
-        const compositeKey2 = getPrimitiveCompositeKey(String(arrayKey2), index2);
+      },
+      select: (...args) => {
+        const data = resolveFieldData(
+          args,
+          stateRef.current,
+          getIndex,
+          getNestedValue
+        );
+        if (!data) return {};
+        const isString = typeof data.value === "string" || data.value === null;
         return {
-          ...getItemUXProps(String(arrayKey2), `@${index2}`, ""),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
+          ...createHandlers(data),
+          selectedKeys: data.value === null ? [] : isString ? [data.value] : data.value,
           onSelectionChange: (v) => {
-            const fixedValue = typeof v === "string" || v === null ? v : String(v);
-            setState((prev) => {
-              const arr3 = [...prev[arrayKey2]];
-              arr3[index2] = fixedValue;
-              return { ...prev, [arrayKey2]: arr3 };
-            });
-            validateItemInput(arrayKey2, `@${index2}`, "", fixedValue);
-          },
-          selectedKey: value2
+            const fixed = typeof v === "string" || v === null ? v : isString ? Array.from(v)[0] || null : Array.from(v);
+            handleFieldChange(data, fixed);
+          }
         };
-      }
-      if (args.length === 4) {
-        const [parentKey, parentId, field2, index2] = args;
-        const parentIndex = getIndex(String(parentKey), parentId);
-        const arr2 = state[parentKey];
-        const nestedArr = parentIndex !== void 0 ? getNestedValue(arr2[parentIndex], field2) : void 0;
-        const value2 = Array.isArray(nestedArr) ? nestedArr[index2] : null;
-        const compositeKey2 = getNestedPrimitiveCompositeKey(
-          String(parentKey),
-          parentId,
-          field2,
-          index2
+      },
+      autocomplete: (...args) => {
+        const data = resolveFieldData(
+          args,
+          stateRef.current,
+          getIndex,
+          getNestedValue
         );
+        if (!data) return {};
         return {
-          ...getItemUXProps(String(parentKey), parentId, `${field2}.@${index2}`),
-          id: compositeKey2,
-          onBlur: () => {
-            if (touched.get(compositeKey2)) return;
-            setTouched((prev) => new Map(prev).set(compositeKey2, true));
-          },
+          ...createHandlers(data),
+          selectedKey: data.value,
           onSelectionChange: (v) => {
-            if (parentIndex === void 0) return;
-            const fixedValue = typeof v === "string" || v === null ? v : String(v);
-            setState((prev) => {
-              const parentArr = [...prev[parentKey]];
-              const item = { ...parentArr[parentIndex] };
-              const nestedArr2 = [...getNestedValue(item, field2) || []];
-              nestedArr2[index2] = fixedValue;
-              parentArr[parentIndex] = setNestedValue(item, field2, nestedArr2);
-              return { ...prev, [parentKey]: parentArr };
-            });
-            const fieldPath = `${field2}.@${index2}`;
-            validateItemInput(parentKey, parentId, fieldPath, fixedValue);
-          },
-          selectedKey: value2
+            const fixed = typeof v === "string" || v === null ? v : String(v);
+            handleFieldChange(data, fixed);
+          }
         };
       }
-      const [arrayKey, itemId, field] = args;
-      const index = getIndex(String(arrayKey), itemId);
-      const arr = state[arrayKey];
-      const value = index !== void 0 ? getNestedValue(arr[index], field) : null;
-      const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
-      return {
-        ...getItemUXProps(String(arrayKey), itemId, field),
-        id: compositeKey,
-        onBlur: () => onItemBlur(arrayKey, itemId, field),
-        onSelectionChange: (v) => onItemSelectionChange(arrayKey, itemId, field, v),
-        selectedKey: value
-      };
-    }
-  };
-  return {
-    onBlur,
-    onValueChange,
-    onSelectionChange,
-    state,
-    setState,
-    touched,
-    errors: errors2,
-    on,
-    helpers: {
+    }),
+    [createHandlers, getIndex, handleFieldChange]
+  );
+  const helpers = (0, import_react2.useMemo)(
+    () => ({
       addItem: (arrayKey, item, index) => {
         setState((prev) => {
           const arr = [...prev[arrayKey]];
-          if (index === void 0) {
-            arr.push(item);
-          } else {
-            arr.splice(index, 0, item);
-          }
+          if (index === void 0) arr.push(item);
+          else arr.splice(index, 0, item);
           return { ...prev, [arrayKey]: arr };
         });
       },
       removeItem: (arrayKey, index) => {
-        const itemIdKey = arrayIdentifiers?.[arrayKey] || "id";
-        const item = state[arrayKey][index];
-        const itemId = item?.[itemIdKey];
+        const currentArr = stateRef.current[arrayKey];
+        const item = currentArr[index];
+        const idKey = arrayIdentifiers?.[arrayKey] || "id";
+        const itemId = item?.[idKey];
         setState((prev) => {
           const arr = [...prev[arrayKey]];
           arr.splice(index, 1);
@@ -749,21 +658,28 @@ 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) => {
-        const index = getIndex(String(arrayKey), itemId);
+        const index = getIndex(arrayKey, itemId);
         if (index !== void 0) {
-          const arr = [...state[arrayKey]];
-          arr.splice(index, 1);
-          setState((prev) => ({ ...prev, [arrayKey]: arr }));
+          setState((prev) => {
+            const arr = [...prev[arrayKey]];
+            arr.splice(index, 1);
+            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) => {
+        setState((prev) => {
+          const arr = [...prev[arrayKey]];
+          arr[index] = value;
+          return { ...prev, [arrayKey]: arr };
+        });
+      },
       moveItem: (arrayKey, from, to) => {
         setState((prev) => {
           const arr = [...prev[arrayKey]];
@@ -773,8 +689,8 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
         });
       },
       moveById: (arrayKey, fromId, toId) => {
-        const fromIndex = getIndex(String(arrayKey), fromId);
-        const toIndex = getIndex(String(arrayKey), toId);
+        const fromIndex = getIndex(arrayKey, fromId);
+        const toIndex = getIndex(arrayKey, toId);
         if (fromIndex !== void 0 && toIndex !== void 0) {
           setState((prev) => {
             const arr = [...prev[arrayKey]];
@@ -784,50 +700,117 @@ function useForm(initialState, { rules, messages, arrayIdentifiers } = {}) {
           });
         }
       },
-      updateItem: (arrayKey, index, value) => {
-        setState((prev) => {
-          const arr = [...prev[arrayKey]];
-          arr[index] = value;
-          return { ...prev, [arrayKey]: arr };
-        });
-      },
       getItem: (arrayKey, itemId) => {
-        const index = getIndex(String(arrayKey), itemId);
-        if (index !== void 0) {
-          return state[arrayKey][index];
-        }
-        return void 0;
+        const index = getIndex(arrayKey, itemId);
+        if (index === void 0) return void 0;
+        return stateRef.current[arrayKey][index];
       }
+    }),
+    [getIndex, arrayIdentifiers]
+  );
+  const onBlur = (0, import_react2.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;
+      });
     },
-    isDirty: JSON.stringify(state) !== JSON.stringify(initialState),
-    hasInvalidValues: () => {
-      const isInvalid = Array.from(errors2.values()).some((e) => e?.isInvalid);
-      return isInvalid;
-    },
-    resetForm: (preservedKeys) => {
-      setTouched(/* @__PURE__ */ new Map());
-      setErrors(/* @__PURE__ */ new Map());
-      setState(
-        (prev) => preservedKeys === void 0 ? initialState : preservedKeys.reduce(
-          (acc, key) => ({
-            ...acc,
-            [key]: prev[key]
-          }),
-          initialState
-        )
+    [validateField]
+  );
+  const polymorphicOnValueChange = (0, import_react2.useCallback)(
+    (...args) => {
+      const value = args[args.length - 1];
+      const idArgs = args.slice(0, args.length - 1);
+      const data = resolveFieldData(
+        idArgs,
+        stateRef.current,
+        getIndex,
+        getNestedValue
       );
+      if (data) handleFieldChange(data, value);
     },
-    resetTouched: (preservedKeys) => {
-      setTouched(
-        (prev) => preservedKeys === void 0 ? /* @__PURE__ */ new Map() : preservedKeys.reduce((acc, key) => {
-          if (prev.has(String(key))) {
-            acc.set(String(key), prev.get(String(key)));
-          }
-          return acc;
-        }, /* @__PURE__ */ new Map())
-      );
-    }
-  };
+    [getIndex, handleFieldChange]
+  );
+  const polymorphicOnSelectionChange = (0, import_react2.useCallback)(
+    (id, val) => {
+      const fixed = typeof val === "string" || val === null ? val : Array.from(val);
+      setState((prev) => handleNestedChange({ state: prev, id, value: fixed }));
+      validateField(String(id), String(id), fixed);
+    },
+    [validateField]
+  );
+  const onSubmit = (0, import_react2.useCallback)(
+    (fn) => (e) => {
+      e.preventDefault();
+      if (validateAll()) return;
+      fn(stateRef.current, e);
+    },
+    [validateAll]
+  );
+  return (0, import_react2.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
+    ]
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {