@juantroconisf/lib 6.0.0 → 7.0.0

package/dist/index.mjs

@@ -16,7 +16,7 @@ var NextUIError = class {
 };
 
 // src/hooks/useForm.tsx
-import { useState, useCallback, useMemo } from "react";
+import { useState, useCallback, useMemo, useRef } from "react";
 
 // src/utils/utils.ts
 function handleNestedChange({
@@ -199,524 +199,387 @@ function useValidate() {
   return { performValidations };
 }
 
+// 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
+        };
+      }
+    }
+    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,
-  arrayRules,
-  arrayMessages,
-  arrayIdentifiers
-} = {}) {
-  const [state, setState] = useState(initialState), [touched, setTouched] = useState(/* @__PURE__ */ new Map()), [errors2, setErrors] = useState(/* @__PURE__ */ new Map()), { performValidations } = useValidate();
+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);
+  stateRef.current = state;
+  touchedRef.current = touched;
+  errorsRef.current = errors2;
   const indexMap = useMemo(() => {
     const map2 = /* @__PURE__ */ new Map();
-    for (const key in state) {
-      if (Array.isArray(state[key])) {
+    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);
+        map2.set(path, itemMap);
+      } else {
+        Object.keys(current).forEach((key) => {
+          const nextPath = path ? `${path}.${key}` : key;
+          traverse(current[key], nextPath);
+        });
       }
-    }
+    };
+    traverse(state, "");
     return map2;
   }, [state, arrayIdentifiers]);
-  const getIndex = useCallback(
-    (arrayKey, itemId) => {
-      return indexMap.get(arrayKey)?.get(itemId);
+  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];
     },
-    [indexMap]
+    [rules]
   );
-  const validateInput = (compositeKey, value, ruleKey) => {
-    const error = performValidations(
-      value,
-      rules?.[ruleKey],
-      messages?.[ruleKey]
-    );
-    setErrors((prev) => new Map(prev).set(compositeKey, error));
-  };
-  const getUXProps = useCallback(
-    (compositeKey) => {
-      const inputError = errors2.get(compositeKey);
-      const isTouched = touched.get(compositeKey);
-      return {
-        isInvalid: Boolean(isTouched && inputError?.isInvalid),
-        errorMessage: isTouched ? inputError?.errorMessage || "" : ""
-      };
+  const getMessage = useCallback(
+    (path) => {
+      if (messages?.[path]) return messages[path];
+      const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
+      return messages?.[genericPath];
     },
-    [errors2, touched]
+    [messages]
   );
-  const onBlur = (id) => {
-    validateInput(String(id), state[id], 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, 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;
-    }
-    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 };
+  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+/, ""));
+      }
+      const error = performValidations(value, rule, message);
+      setErrors((prev) => {
+        const newMap = new Map(prev);
+        newMap.set(compositeKey, error);
+        return newMap;
       });
-      return;
-    }
-  }), 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, 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 arrayRuleDef = arrayRules?.[arrayKey]?.[field];
-    const item = state[arrayKey][index];
-    const fieldRules = typeof arrayRuleDef === "function" ? arrayRuleDef(item, index) : arrayRuleDef;
-    const fieldMessages = arrayMessages?.[arrayKey]?.[field];
-    const compositeKey = getItemCompositeKey(String(arrayKey), itemId, field);
-    setErrors(
-      (prev) => new Map(prev).set(
-        compositeKey,
-        performValidations(value, fieldRules, fieldMessages)
-      )
-    );
-  };
-  const getItemUXProps = 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 || "" : ""
-      };
+      return error.isInvalid;
     },
-    [errors2, touched]
+    [getRule, getMessage, performValidations]
   );
-  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 topKey = dotPath.split(".")[0];
-    setErrors(
-      (prev) => new Map(prev).set(
-        dotPath,
-        performValidations(value, rules?.[topKey], messages?.[topKey])
-      )
-    );
-  };
-  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]
-          };
+  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;
         }
-        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
-        };
       }
-      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
-        };
-      }
-      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
-      };
-    },
-    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]
-          };
+      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;
+          });
         }
-        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
-        };
+      } 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;
       }
-      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]
-        };
-      }
-      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]
+    };
+    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]);
+  const handleFieldChange = useCallback(
+    (resolution, newValue) => {
+      if (!resolution) return;
+      const {
+        type,
+        compositeKey,
+        fieldPath,
+        arrayKey,
+        index,
+        parentKey,
+        parentId,
+        nestedField
+      } = resolution;
+      setState((prev) => {
+        if (type === "scalar" /* Scalar */) {
+          return handleNestedChange({
+            state: prev,
+            id: compositeKey,
+            value: newValue
+          });
+        }
+        if (type === "primitiveArray" /* PrimitiveArray */) {
+          const arr = [...prev[arrayKey]];
+          arr[index] = newValue;
+          return { ...prev, [arrayKey]: arr };
+        }
+        if (type === "objectArray" /* ObjectArray */) {
+          return handleArrayItemChange({
+            state: prev,
+            arrayKey,
+            index,
+            field: resolution.field,
+            value: newValue
+          });
+        }
+        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] = newValue;
+          pItem[nestedField] = nestedArr;
+          const updatedItem = setNestedValue(pItem, nestedField, nestedArr);
+          parentArr[pIndex] = updatedItem;
+          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]
         };
       }
-      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);
+      validateField(compositeKey, fieldPath, newValue, extraContext);
+    },
+    [getIndex, validateField]
+  );
+  const createHandlers = useCallback(
+    (resolution) => {
+      if (!resolution) return {};
+      const { compositeKey, fieldPath, value } = resolution;
+      const err = errorsRef.current.get(compositeKey);
+      const isTouched = touchedRef.current.get(compositeKey);
       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 && err?.isInvalid),
+        errorMessage: isTouched ? err?.errorMessage || "" : "",
+        onBlur: () => {
+          if (touchedRef.current.get(compositeKey)) return;
+          validateField(compositeKey, fieldPath, value);
+          setTouched((prev) => new Map(prev).set(compositeKey, true));
+        }
       };
     },
-    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 = 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 = 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);
@@ -729,16 +592,25 @@ function useForm(initialState, {
         }
       },
       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));
         }
       },
+      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]];
@@ -748,8 +620,8 @@ function useForm(initialState, {
         });
       },
       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]];
@@ -759,48 +631,80 @@ function useForm(initialState, {
           });
         }
       },
-      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 = (id) => {
+    validateField(String(id), String(id), stateRef.current[id]);
+    setTouched((prev) => new Map(prev).set(String(id), true));
+  };
+  const polymorphicOnValueChange = 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);
     },
-    isDirty: JSON.stringify(state) !== JSON.stringify(initialState),
-    hasInvalidValues: () => {
-      const isInvalid = Array.from(errors2.values()).some((e) => e?.isInvalid);
-      return isInvalid;
+    [getIndex, handleFieldChange]
+  );
+  const polymorphicOnSelectionChange = 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]
+  );
+  return {
+    state,
+    setState,
+    touched,
+    errors: errors2,
+    on,
+    helpers,
+    onBlur,
+    onValueChange: polymorphicOnValueChange,
+    onSelectionChange: polymorphicOnSelectionChange,
+    isDirty: touched.size > 0,
+    hasInvalidValues: validateAll,
     resetForm: (preservedKeys) => {
+      if (preservedKeys && preservedKeys.length > 0) {
+        const nextState = { ...initialState };
+        preservedKeys.forEach((k) => {
+          if (stateRef.current[k] !== void 0)
+            nextState[k] = stateRef.current[k];
+        });
+        setState(nextState);
+      } else {
+        setState(initialState);
+      }
       setTouched(/* @__PURE__ */ new Map());
       setErrors(/* @__PURE__ */ new Map());
-      setState(
-        (prev) => preservedKeys === void 0 ? initialState : preservedKeys.reduce(
-          (acc, key) => ({
-            ...acc,
-            [key]: prev[key]
-          }),
-          initialState
-        )
-      );
     },
     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)));
+      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 acc;
-        }, /* @__PURE__ */ new Map())
-      );
+          return next;
+        });
+      } else {
+        setTouched(/* @__PURE__ */ new Map());
+      }
     }
   };
 }