@juantroconisf/lib 11.8.0 → 11.10.0

package/dist/index.js

@@ -35,74 +35,8 @@ var NextUIError = class {
 };
 
 // src/hooks/useForm.tsx
-var import_react2 = require("react");
-
-// src/utils/utils.ts
-function handleNestedChange({
-  state,
-  id,
-  value,
-  hasNestedValues = false
-}) {
-  const isNested = hasNestedValues || String(id).includes(".");
-  if (!isNested) return { ...state, [id]: value };
-  const keys = String(id).split(".");
-  const newState = { ...state };
-  let current = newState;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (Array.isArray(current[key])) {
-      current[key] = [...current[key]];
-    } else {
-      current[key] = { ...current[key] };
-    }
-    current = current[key];
-  }
-  current[keys[keys.length - 1]] = value;
-  return newState;
-}
-function handleArrayItemChange({
-  state,
-  arrayKey,
-  index,
-  field,
-  value
-}) {
-  const arr = [...state[arrayKey]];
-  const item = { ...arr[index] };
-  const fieldDepth = field.split(".");
-  if (fieldDepth.length === 1) {
-    item[field] = value;
-  } else {
-    let current = item;
-    for (let i = 0; i < fieldDepth.length - 1; i++) {
-      if (Array.isArray(current[fieldDepth[i]])) {
-        current[fieldDepth[i]] = [...current[fieldDepth[i]]];
-      } else {
-        current[fieldDepth[i]] = { ...current[fieldDepth[i]] };
-      }
-      current = current[fieldDepth[i]];
-    }
-    current[fieldDepth[fieldDepth.length - 1]] = value;
-  }
-  arr[index] = item;
-  return { ...state, [arrayKey]: arr };
-}
-function getNestedValue(obj, path) {
-  return path.split(".").reduce((acc, key) => acc?.[key], obj);
-}
-function removeCompositeKeysByPrefix(map, prefix) {
-  const result = new Map(map);
-  for (const key of map.keys()) {
-    if (key.startsWith(prefix)) {
-      result.delete(key);
-    }
-  }
-  return result;
-}
-
-// src/hooks/useForm.tsx
-var import_react3 = require("@heroui/react");
+var import_react6 = require("react");
+var import_react7 = require("@heroui/react");
 
 // src/hooks/useComponentLang.tsx
 var import_yup = require("yup");
@@ -220,8 +154,64 @@ function useComponentLanguage() {
   }, []);
 }
 
-// src/hooks/useForm.utils.ts
-function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, validationSchema) {
+// src/hooks/useForm/utils.ts
+var import_yup2 = require("yup");
+function resolveLabel(id) {
+  const fallback = () => {
+    const lastPart = id.split(".").pop() || id;
+    return lastPart.charAt(0).toUpperCase() + lastPart.slice(1);
+  };
+  if (typeof document === "undefined") return fallback();
+  const el = document.getElementById(id);
+  if (!el) return fallback();
+  if (el.ariaLabelledByElements?.[0]) {
+    const text = el.ariaLabelledByElements[0].innerText || el.ariaLabelledByElements[0].textContent;
+    if (text) return text.trim();
+  }
+  const labelledBy = el.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const labelEl = document.getElementById(labelledBy);
+    const text = labelEl?.innerText || labelEl?.textContent;
+    if (text) return text.trim();
+  }
+  if (el.labels?.[0]) {
+    const text = el.labels[0].innerText || el.labels[0].textContent;
+    if (text) return text.trim();
+  }
+  return fallback();
+}
+function getRule(path, schema, ruleCache) {
+  if (ruleCache.has(path)) {
+    return ruleCache.get(path);
+  }
+  let rule;
+  try {
+    rule = (0, import_yup2.reach)(schema, path);
+  } catch {
+    const genericPath = path.replace(/\.\d+\./g, ".").replace(/\.\d+$/, "");
+    try {
+      rule = (0, import_yup2.reach)(schema, genericPath);
+    } catch {
+      rule = void 0;
+    }
+  }
+  ruleCache.set(path, rule);
+  return rule;
+}
+function getIndex(arrayKey, itemId, indexMap) {
+  const map = indexMap.get(arrayKey);
+  if (!map) return void 0;
+  const index = map.get(itemId);
+  if (index !== void 0) return index;
+  if (typeof itemId === "string") {
+    const num = Number(itemId);
+    if (!isNaN(num)) return map.get(num);
+  } else if (typeof itemId === "number") {
+    return map.get(String(itemId));
+  }
+  return void 0;
+}
+function resolveFieldData(args, state, getIndexFn, getNestedValue2, getRuleFn, validationSchema) {
   const argCount = args.length;
   if (argCount === 1) {
     const id = args[0];
@@ -242,7 +232,7 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
       if (Array.isArray(state[arrayKey2])) {
         const field = parts.slice(1).join(".");
         const itemId = arg1;
-        const index2 = getIndex(arrayKey2, itemId);
+        const index2 = getIndexFn(arrayKey2, itemId);
         if (index2 === void 0) return null;
         const arr2 = state[arrayKey2];
         const item = arr2[index2];
@@ -251,7 +241,6 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
           type: "objectArray" /* ObjectArray */,
           compositeKey: `${arrayKey2}.${itemId}.${field}`,
           fieldPath: arg0,
-          // "array.field"
           realPath: `${arrayKey2}.${index2}.${field}`,
           value,
           arrayKey: arrayKey2,
@@ -276,7 +265,7 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
   }
   if (argCount === 3) {
     const [arrayKey, itemId, field] = args;
-    const index = getIndex(arrayKey, itemId);
+    const index = getIndexFn(arrayKey, itemId);
     if (index === void 0) return null;
     const arr = state[arrayKey];
     const item = arr[index];
@@ -285,7 +274,6 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
       type: "objectArray" /* ObjectArray */,
       compositeKey: `${arrayKey}.${itemId}.${field}`,
       fieldPath: `${arrayKey}.${field}`,
-      // Normalized path for rules
       realPath: `${arrayKey}.${index}.${field}`,
       value,
       arrayKey,
@@ -296,7 +284,7 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
   }
   if (argCount === 4) {
     const [parentKey, parentId, field, index] = args;
-    const parentIndex = getIndex(parentKey, parentId);
+    const parentIndex = getIndexFn(parentKey, parentId);
     if (parentIndex === void 0) return null;
     const arr = state[parentKey];
     const item = arr[parentIndex];
@@ -306,7 +294,6 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
       type: "nestedPrimitiveArray" /* NestedPrimitiveArray */,
       compositeKey: `${parentKey}.${parentId}.${field}.@${index}`,
       fieldPath: `${parentKey}.${field}`,
-      // Roughly?
       realPath: `${parentKey}.${parentIndex}.${field}.${index}`,
       value,
       parentKey,
@@ -327,15 +314,15 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
     );
     for (const part of parts) {
       let isArrayContext = Array.isArray(current);
-      if (!isArrayContext && getRule && validationSchema) {
+      if (!isArrayContext && getRuleFn && validationSchema) {
         const currentFieldPath = fieldPathParts.filter(Boolean).join(".");
-        const rule = getRule(currentFieldPath, validationSchema);
+        const rule = getRuleFn(currentFieldPath, validationSchema);
         if (rule && rule.type === "array") {
           isArrayContext = true;
         }
       }
       if (isArrayContext) {
-        let indexNum = getIndex(currentPath, part);
+        let indexNum = getIndexFn(currentPath, part);
         if (indexNum === void 0 && typeof part === "number") {
           indexNum = part;
         }
@@ -362,21 +349,18 @@ function resolveFieldData(args, state, getIndex, getNestedValue2, getRule, valid
   return null;
 }
 
-// src/hooks/useForm.tsx
-var import_yup2 = require("yup");
-var import_jsx_runtime = require("react/jsx-runtime");
+// src/hooks/useForm/constants.ts
 var DEFAULT_OPTIONS = {};
-function useForm(schema, {
-  arrayIdentifiers,
-  onFormSubmit: onFormSubmitProp,
-  resetOnSubmit = false,
-  keepValues: keepValuesProp
-} = DEFAULT_OPTIONS) {
+
+// src/hooks/useForm/useFormState.ts
+var import_react2 = require("react");
+var import_yup3 = require("yup");
+function useFormState(schema, arrayIdentifiers) {
   const { initialState, validationSchema } = (0, import_react2.useMemo)(() => {
     const state2 = {};
     const extractedRules = {};
     Object.entries(schema).forEach(([key, value]) => {
-      if ((0, import_yup2.isSchema)(value)) {
+      if ((0, import_yup3.isSchema)(value)) {
         try {
           state2[key] = value.cast(void 0);
         } catch {
@@ -389,12 +373,14 @@ function useForm(schema, {
     });
     return {
       initialState: state2,
-      validationSchema: (0, import_yup2.object)().shape(extractedRules)
+      validationSchema: (0, import_yup3.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), propsCache = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const [state, setState] = (0, import_react2.useState)(initialState);
+  const [metadata, setMetadata] = (0, import_react2.useState)(/* @__PURE__ */ new Map());
+  const stateRef = (0, import_react2.useRef)(state);
+  const metadataRef = (0, import_react2.useRef)(metadata);
+  const propsCache = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
   stateRef.current = state;
   metadataRef.current = metadata;
   const indexMap = (0, import_react2.useMemo)(() => {
@@ -427,44 +413,28 @@ function useForm(schema, {
   }, [state, arrayIdentifiers]);
   const indexMapRef = (0, import_react2.useRef)(indexMap);
   indexMapRef.current = indexMap;
-  const getIndex = (0, import_react2.useCallback)((arrayKey, itemId) => {
-    const map = indexMapRef.current.get(arrayKey);
-    if (!map) return void 0;
-    const index = map.get(itemId);
-    if (index !== void 0) return index;
-    if (typeof itemId === "string") {
-      const num = Number(itemId);
-      if (!isNaN(num)) return map.get(num);
-    } else if (typeof itemId === "number") {
-      return map.get(String(itemId));
-    }
-    return void 0;
-  }, []);
-  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);
-    }
-    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;
-      }
-    }
-    ruleCache.current.set(path, rule);
-    return rule;
-  }, []);
-  const runValidation = (0, import_react2.useCallback)(
+  return {
+    state,
+    setState,
+    metadata,
+    setMetadata,
+    stateRef,
+    metadataRef,
+    propsCache,
+    indexMap,
+    indexMapRef,
+    initialState,
+    validationSchema
+  };
+}
+
+// src/hooks/useForm/useValidation.ts
+var import_react3 = require("react");
+var import_yup4 = require("yup");
+function useValidation(validationSchema, stateRef, metadataRef, setMetadata, arrayIdentifiers, ruleCache) {
+  const runValidation = (0, import_react3.useCallback)(
     (ruleDef, value, compositeKey, realPath, fullState) => {
-      if ((0, import_yup2.isSchema)(ruleDef)) {
+      if ((0, import_yup4.isSchema)(ruleDef)) {
         const updateMetadata = (err) => {
           const error = {
             isInvalid: true,
@@ -510,11 +480,11 @@ function useForm(schema, {
       }
       return false;
     },
-    [validationSchema]
+    [validationSchema, setMetadata]
   );
-  const validateField = (0, import_react2.useCallback)(
+  const validateField = (0, import_react3.useCallback)(
     (compositeKey, fieldPath, realPath, value, fullState) => {
-      let schemaRule = getRule(fieldPath, validationSchema);
+      let schemaRule = getRule(fieldPath, validationSchema, ruleCache.current);
       if (schemaRule) {
         const result = runValidation(
           schemaRule,
@@ -550,24 +520,73 @@ function useForm(schema, {
       clearError();
       return false;
     },
-    [getRule, runValidation, validationSchema]
+    [validationSchema, ruleCache, runValidation, setMetadata]
+  );
+  const validateFields = (0, import_react3.useCallback)(
+    async (paths) => {
+      if (!validationSchema) return { isValid: true, errors: [], results: [] };
+      const errors = [];
+      const results = [];
+      const newMetadata = new Map(metadataRef.current);
+      for (const path of paths) {
+        const compositeKey = String(path);
+        try {
+          await validationSchema.validateAt(compositeKey, stateRef.current);
+          const currentMeta = newMetadata.get(compositeKey);
+          if (currentMeta?.isInvalid) {
+            newMetadata.set(compositeKey, {
+              ...currentMeta,
+              isInvalid: false,
+              errorMessage: ""
+            });
+          }
+        } catch (err) {
+          if (err.name === "ValidationError") {
+            errors.push(compositeKey);
+            const currentMeta = newMetadata.get(compositeKey) || {
+              isTouched: false,
+              isInvalid: false,
+              errorMessage: ""
+            };
+            const label = currentMeta.label || resolveLabel(compositeKey);
+            results.push({ id: compositeKey, label, message: err.message });
+            newMetadata.set(compositeKey, {
+              ...currentMeta,
+              isTouched: true,
+              isInvalid: true,
+              errorMessage: err.message,
+              label
+            });
+          }
+        }
+      }
+      setMetadata(newMetadata);
+      return { isValid: errors.length === 0, errors, results };
+    },
+    [validationSchema, metadataRef, stateRef, setMetadata]
   );
-  const validateAll = (0, import_react2.useCallback)(() => {
-    if (!validationSchema) return false;
+  const validateAll = (0, import_react3.useCallback)(() => {
+    if (!validationSchema)
+      return Promise.resolve({ isValid: true, errors: [], results: [] });
     const cleanMetadata = new Map(metadataRef.current);
     cleanMetadata.forEach((value, key) => {
       if (value.isInvalid) {
-        cleanMetadata.set(key, { ...value, isInvalid: false, errorMessage: "" });
+        cleanMetadata.set(key, {
+          ...value,
+          isInvalid: false,
+          errorMessage: ""
+        });
       }
     });
     const handleErrors = (err) => {
       const newMetadata = new Map(cleanMetadata);
+      const errors = [];
+      const results = [];
       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 cleanPath = validationError.path.replace(/\["([^"]+)"\]/g, ".$1").replace(/\['([^']+)'\]/g, ".$1").replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+          const parts = cleanPath.split(".");
+          let current = stateRef.current;
           const compositeParts = [];
           for (let i = 0; i < parts.length; i++) {
             const part = parts[i];
@@ -589,42 +608,128 @@ function useForm(schema, {
             }
           }
           const compositeKey = compositeParts.join(".");
+          errors.push(compositeKey);
           const currentMeta = newMetadata.get(compositeKey) || {
             isTouched: false,
             isInvalid: false,
             errorMessage: ""
           };
+          const label = currentMeta.label || resolveLabel(compositeKey);
+          const errorResult = {
+            id: compositeKey,
+            label,
+            message: validationError.message
+          };
+          results.push(errorResult);
           newMetadata.set(compositeKey, {
             ...currentMeta,
             isTouched: true,
             isInvalid: true,
-            errorMessage: validationError.message
+            errorMessage: validationError.message,
+            label
           });
         });
       }
       setMetadata(newMetadata);
-      return true;
+      return { isValid: false, errors, results };
     };
     try {
-      validationSchema.validateSync(state, { abortEarly: false });
+      validationSchema.validateSync(stateRef.current, { abortEarly: false });
     } catch (err) {
       if (err.name === "ValidationError") {
-        return handleErrors(err);
+        return Promise.resolve(handleErrors(err));
       }
       return (async () => {
         try {
-          await validationSchema.validate(state, { abortEarly: false });
+          await validationSchema.validate(stateRef.current, { abortEarly: false });
           setMetadata(cleanMetadata);
-          return false;
+          return { isValid: true, errors: [], results: [] };
         } catch (asyncErr) {
           return handleErrors(asyncErr);
         }
       })();
     }
     setMetadata(cleanMetadata);
-    return false;
-  }, [validationSchema, state, arrayIdentifiers]);
-  const handleFieldChange = (0, import_react2.useCallback)(
+    return Promise.resolve({ isValid: true, errors: [], results: [] });
+  }, [validationSchema, metadataRef, stateRef, arrayIdentifiers, setMetadata]);
+  return {
+    validateField,
+    validateFields,
+    validateAll,
+    runValidation
+  };
+}
+
+// src/hooks/useForm/useHandlers.ts
+var import_react4 = require("react");
+
+// src/utils/utils.ts
+function handleNestedChange({
+  state,
+  id,
+  value,
+  hasNestedValues = false
+}) {
+  const isNested = hasNestedValues || String(id).includes(".");
+  if (!isNested) return { ...state, [id]: value };
+  const keys = String(id).split(".");
+  const newState = { ...state };
+  let current = newState;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (Array.isArray(current[key])) {
+      current[key] = [...current[key]];
+    } else {
+      current[key] = { ...current[key] };
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return newState;
+}
+function handleArrayItemChange({
+  state,
+  arrayKey,
+  index,
+  field,
+  value
+}) {
+  const arr = [...state[arrayKey]];
+  const item = { ...arr[index] };
+  const fieldDepth = field.split(".");
+  if (fieldDepth.length === 1) {
+    item[field] = value;
+  } else {
+    let current = item;
+    for (let i = 0; i < fieldDepth.length - 1; i++) {
+      if (Array.isArray(current[fieldDepth[i]])) {
+        current[fieldDepth[i]] = [...current[fieldDepth[i]]];
+      } else {
+        current[fieldDepth[i]] = { ...current[fieldDepth[i]] };
+      }
+      current = current[fieldDepth[i]];
+    }
+    current[fieldDepth[fieldDepth.length - 1]] = value;
+  }
+  arr[index] = item;
+  return { ...state, [arrayKey]: arr };
+}
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function removeCompositeKeysByPrefix(map, prefix) {
+  const result = new Map(map);
+  for (const key of map.keys()) {
+    if (key.startsWith(prefix)) {
+      result.delete(key);
+    }
+  }
+  return result;
+}
+
+// src/hooks/useForm/useHandlers.ts
+function useHandlers(stateRef, setState, metadataRef, setMetadata, validationSchema, ruleCache, propsCache, getIndex3, validateField) {
+  const handleFieldChange = (0, import_react4.useCallback)(
     (resolution, newValue) => {
       if (!resolution) return;
       const {
@@ -638,7 +743,7 @@ function useForm(schema, {
         nestedField
       } = resolution;
       let finalValue = newValue;
-      let rule = getRule(fieldPath, validationSchema);
+      let rule = getRule(fieldPath, validationSchema, ruleCache.current);
       if (rule && rule.type === "array" && type === "primitiveArray" /* PrimitiveArray */ && rule.innerType) {
         rule = rule.innerType;
       }
@@ -696,7 +801,7 @@ function useForm(schema, {
           value: finalValue
         });
       } else if (type === "nestedPrimitiveArray" /* NestedPrimitiveArray */) {
-        const pIndex = getIndex(parentKey, parentId);
+        const pIndex = getIndex3(parentKey, parentId);
         if (pIndex !== void 0) {
           const parentArr = [...nextState[parentKey]];
           const pItem = { ...parentArr[pIndex] };
@@ -723,9 +828,9 @@ function useForm(schema, {
         nextState
       );
     },
-    [getIndex, validateField, getRule, validationSchema]
+    [stateRef, setState, validationSchema, ruleCache, getIndex3, validateField]
   );
-  const createHandlers = (0, import_react2.useCallback)(
+  const createHandlers = (0, import_react4.useCallback)(
     (resolution) => {
       if (!resolution) return {};
       const { compositeKey, fieldPath, realPath, value } = resolution;
@@ -733,7 +838,7 @@ function useForm(schema, {
       const isTouched = meta?.isTouched;
       let isRequired = false;
       try {
-        const rule = getRule(fieldPath, validationSchema);
+        const rule = getRule(fieldPath, validationSchema, ruleCache.current);
         if (rule) isRequired = rule.describe().optional === false;
       } catch {
       }
@@ -759,100 +864,113 @@ function useForm(schema, {
               isInvalid: false,
               errorMessage: ""
             };
-            newMap.set(compositeKey, { ...current, isTouched: true });
+            const label = current.label || resolveLabel(compositeKey);
+            newMap.set(compositeKey, {
+              ...current,
+              isTouched: true,
+              label
+            });
             return newMap;
           });
         }
       };
     },
-    [validateField, getRule, validationSchema]
+    [validationSchema, ruleCache, metadataRef, setMetadata, validateField, stateRef]
   );
-  const on = (0, import_react2.useMemo)(
-    () => {
-      const getCachedProps = (method, args, factory) => {
-        const data = resolveFieldData(
-          args,
-          stateRef.current,
-          getIndex,
-          getNestedValue,
-          getRule,
-          validationSchema
-        );
-        if (!data) return {};
-        const meta = metadataRef.current.get(data.compositeKey);
-        const deps = JSON.stringify([
-          data.value,
-          meta?.isInvalid,
-          meta?.errorMessage,
-          meta?.isTouched
-        ]);
-        const cacheKey = `${method}:${JSON.stringify(args)}`;
-        const cached = propsCache.current.get(cacheKey);
-        if (cached && cached.deps === deps) {
-          return cached.props;
-        }
-        const props = factory(data);
-        propsCache.current.set(cacheKey, { props, deps });
-        return props;
-      };
-      return {
-        input: (...args) => getCachedProps("input", args, (data) => ({
-          ...createHandlers(data),
-          value: data.value === null || data.value === void 0 ? "" : typeof data.value === "boolean" ? data.value : String(data.value),
-          onValueChange: (v) => handleFieldChange(data, v)
-        })),
-        select: (...args) => getCachedProps("select", args, (data) => {
-          const isArray = Array.isArray(data.value);
-          return {
-            ...createHandlers(data),
-            selectedKeys: data.value === null || data.value === void 0 ? [] : isArray ? data.value.map(String) : [String(data.value)],
-            onSelectionChange: (v) => {
-              const fixed = typeof v === "string" || v === null ? v : isArray ? Array.from(v) : Array.from(v)[0] ?? null;
-              handleFieldChange(data, fixed);
-            }
-          };
-        }),
-        autocomplete: (...args) => getCachedProps("autocomplete", args, (data) => ({
+  const on = (0, import_react4.useMemo)(() => {
+    const getCachedProps = (method, args, factory) => {
+      const data = resolveFieldData(
+        args,
+        stateRef.current,
+        getIndex3,
+        getNestedValue,
+        (p, s) => getRule(p, s, ruleCache.current),
+        validationSchema
+      );
+      if (!data) return {};
+      const meta = metadataRef.current.get(data.compositeKey);
+      const deps = JSON.stringify([
+        data.value,
+        meta?.isInvalid,
+        meta?.errorMessage,
+        meta?.isTouched
+      ]);
+      const cacheKey = `${method}:${JSON.stringify(args)}`;
+      const cached = propsCache.current.get(cacheKey);
+      if (cached && cached.deps === deps) {
+        return cached.props;
+      }
+      const props = factory(data);
+      propsCache.current.set(cacheKey, { props, deps });
+      return props;
+    };
+    return {
+      input: (...args) => getCachedProps("input", args, (data) => ({
+        ...createHandlers(data),
+        value: data.value === null || data.value === void 0 ? "" : typeof data.value === "boolean" ? data.value : String(data.value),
+        onValueChange: (v) => handleFieldChange(data, v)
+      })),
+      select: (...args) => getCachedProps("select", args, (data) => {
+        const isArray = Array.isArray(data.value);
+        return {
           ...createHandlers(data),
-          selectedKey: data.value === null || data.value === void 0 ? null : String(data.value),
+          selectedKeys: data.value === null || data.value === void 0 ? [] : isArray ? data.value.map(String) : [String(data.value)],
           onSelectionChange: (v) => {
-            const fixed = typeof v === "string" || v === null || v === void 0 ? v : String(v);
+            const fixed = typeof v === "string" || v === null ? v : isArray ? Array.from(v) : Array.from(v)[0] ?? null;
             handleFieldChange(data, fixed);
           }
-        })),
-        numberInput: (...args) => getCachedProps("numberInput", args, (data) => ({
-          ...createHandlers(data),
-          value: data.value === null || data.value === void 0 ? "" : String(data.value),
-          onValueChange: (v) => handleFieldChange(data, v)
-        })),
-        checkbox: (...args) => getCachedProps("checkbox", args, (data) => ({
-          ...createHandlers(data),
-          isSelected: Boolean(data.value),
-          onValueChange: (v) => handleFieldChange(data, v)
-        })),
-        switch: (...args) => getCachedProps("switch", args, (data) => ({
-          ...createHandlers(data),
-          isSelected: Boolean(data.value),
-          onValueChange: (v) => handleFieldChange(data, v)
-        })),
-        radio: (...args) => getCachedProps("radio", args, (data) => ({
-          ...createHandlers(data),
-          value: data.value === null || data.value === void 0 ? "" : String(data.value),
-          onValueChange: (v) => handleFieldChange(data, v)
-        }))
-      };
-    },
-    [
-      createHandlers,
-      getIndex,
-      handleFieldChange,
-      getRule,
-      validationSchema,
-      state,
-      metadata
-    ]
-  );
-  const helpers = (0, import_react2.useMemo)(
+        };
+      }),
+      autocomplete: (...args) => getCachedProps("autocomplete", args, (data) => ({
+        ...createHandlers(data),
+        selectedKey: data.value === null || data.value === void 0 ? null : String(data.value),
+        onSelectionChange: (v) => {
+          const fixed = typeof v === "string" || v === null || v === void 0 ? v : String(v);
+          handleFieldChange(data, fixed);
+        }
+      })),
+      numberInput: (...args) => getCachedProps("numberInput", args, (data) => ({
+        ...createHandlers(data),
+        value: data.value === null || data.value === void 0 ? "" : String(data.value),
+        onValueChange: (v) => handleFieldChange(data, v)
+      })),
+      checkbox: (...args) => getCachedProps("checkbox", args, (data) => ({
+        ...createHandlers(data),
+        isSelected: Boolean(data.value),
+        onValueChange: (v) => handleFieldChange(data, v)
+      })),
+      switch: (...args) => getCachedProps("switch", args, (data) => ({
+        ...createHandlers(data),
+        isSelected: Boolean(data.value),
+        onValueChange: (v) => handleFieldChange(data, v)
+      })),
+      radio: (...args) => getCachedProps("radio", args, (data) => ({
+        ...createHandlers(data),
+        value: data.value === null || data.value === void 0 ? "" : String(data.value),
+        onValueChange: (v) => handleFieldChange(data, v)
+      }))
+    };
+  }, [
+    createHandlers,
+    getIndex3,
+    handleFieldChange,
+    ruleCache,
+    validationSchema,
+    stateRef,
+    metadataRef,
+    propsCache
+  ]);
+  return {
+    on,
+    handleFieldChange,
+    createHandlers
+  };
+}
+
+// src/hooks/useForm/useFormHelpers.ts
+var import_react5 = require("react");
+function useFormHelpers(stateRef, setState, setMetadata, metadataRef, arrayIdentifiers, validationSchema, getIndex3, validateAll, validateFields, ruleCache) {
+  const helpers = (0, import_react5.useMemo)(
     () => ({
       addItem: (arrayKey, item, index) => {
         setState((prev) => {
@@ -888,7 +1006,7 @@ function useForm(schema, {
         }
       },
       removeById: (arrayKey, itemId) => {
-        const index = getIndex(arrayKey, itemId);
+        const index = getIndex3(arrayKey, itemId);
         if (index !== void 0) {
           setState((prev) => {
             const arr = [...getNestedValue(prev, arrayKey) || []];
@@ -917,7 +1035,7 @@ function useForm(schema, {
         });
       },
       updateById: (arrayKey, itemId, value) => {
-        const index = getIndex(arrayKey, itemId);
+        const index = getIndex3(arrayKey, itemId);
         if (index !== void 0) {
           setState((prev) => {
             const arr = [...getNestedValue(prev, arrayKey) || []];
@@ -945,8 +1063,8 @@ function useForm(schema, {
         });
       },
       moveById: (arrayKey, fromId, toId) => {
-        const fromIndex = getIndex(arrayKey, fromId);
-        const toIndex = getIndex(arrayKey, toId);
+        const fromIndex = getIndex3(arrayKey, fromId);
+        const toIndex = getIndex3(arrayKey, toId);
         if (fromIndex !== void 0 && toIndex !== void 0) {
           setState((prev) => {
             const arr = [...getNestedValue(prev, arrayKey) || []];
@@ -962,125 +1080,188 @@ function useForm(schema, {
         }
       },
       getItemById: (arrayKey, itemId) => {
-        const index = getIndex(arrayKey, itemId);
+        const index = getIndex3(arrayKey, itemId);
         if (index === void 0) return void 0;
-        return getNestedValue(stateRef.current, arrayKey)[index];
+        return (getNestedValue(stateRef.current, arrayKey) || [])[index];
       },
       validateItem: async (arrayKey, itemId) => {
-        if (!validationSchema) return false;
-        const index = getIndex(arrayKey, itemId);
-        if (index === void 0) return false;
-        const yupPath = `${String(arrayKey)}[${index}]`;
-        const prefix = `${String(arrayKey)}.${itemId}.`;
-        const cleanMetadata = new Map(metadataRef.current);
-        for (const key of cleanMetadata.keys()) {
-          if (key.startsWith(prefix) || key === `${String(arrayKey)}.${itemId}`) {
-            const meta = cleanMetadata.get(key);
-            cleanMetadata.set(key, {
-              ...meta,
-              isInvalid: false,
-              errorMessage: ""
-            });
-          }
-        }
-        const handleErrors = (err) => {
-          const newMetadata = new Map(cleanMetadata);
+        const index = getIndex3(arrayKey, itemId);
+        if (index === void 0)
+          return { isValid: true, errors: [], results: [] };
+        const item = (getNestedValue(stateRef.current, arrayKey) || [])[index];
+        const itemSchema = getRule(String(arrayKey), validationSchema, ruleCache.current)?.innerType;
+        if (!itemSchema) return { isValid: true, errors: [], results: [] };
+        try {
+          await itemSchema.validate(item, { abortEarly: false });
+          const prefix = `${String(arrayKey)}.${itemId}.`;
+          setMetadata((prev) => {
+            const newMap = new Map(prev);
+            let changed = false;
+            for (const [key, meta] of newMap.entries()) {
+              if (key.startsWith(prefix) && meta.isInvalid) {
+                newMap.set(key, { ...meta, isInvalid: false, errorMessage: "" });
+                changed = true;
+              }
+            }
+            return changed ? newMap : prev;
+          });
+          return { isValid: true, errors: [], results: [] };
+        } catch (err) {
+          const errors = [];
+          const results = [];
+          const newMetadata = new Map(metadataRef.current);
           if (err.inner) {
             err.inner.forEach((validationError) => {
-              const localDotPath = validationError.path.replace(
-                /\[(\d+)\]/g,
-                ".$1"
-              );
-              const parts = localDotPath.split(".");
-              let current = stateRef.current;
-              const compositeParts = [];
-              for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                if (Array.isArray(current)) {
-                  const idx = parseInt(part, 10);
-                  const item = current[idx];
-                  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 : idx));
-                  } else {
-                    compositeParts.push(part);
-                  }
-                  current = item;
-                } else {
-                  compositeParts.push(part);
-                  current = current?.[part];
-                }
-              }
-              const compositeKey = compositeParts.join(".");
+              const field = validationError.path;
+              const compositeKey = `${String(arrayKey)}.${itemId}.${field}`;
+              errors.push(compositeKey);
               const currentMeta = newMetadata.get(compositeKey) || {
                 isTouched: false,
                 isInvalid: false,
                 errorMessage: ""
               };
+              const label = currentMeta.label || resolveLabel(compositeKey);
+              const errorResult = {
+                id: compositeKey,
+                label,
+                message: validationError.message
+              };
+              results.push(errorResult);
               newMetadata.set(compositeKey, {
                 ...currentMeta,
                 isTouched: true,
                 isInvalid: true,
-                errorMessage: validationError.message
+                errorMessage: validationError.message,
+                label
               });
             });
           }
           setMetadata(newMetadata);
-          return true;
-        };
-        try {
-          await validationSchema.validateAt(yupPath, stateRef.current, {
-            abortEarly: false
-          });
-          setMetadata(cleanMetadata);
-          return false;
-        } catch (err) {
-          if (err.name === "ValidationError") {
-            return handleErrors(err);
-          }
-          return false;
+          return { isValid: false, errors, results };
         }
-      }
+      },
+      validateAll,
+      validateFields
     }),
-    [getIndex, arrayIdentifiers, state, metadata]
+    [
+      stateRef,
+      setState,
+      setMetadata,
+      metadataRef,
+      arrayIdentifiers,
+      validationSchema,
+      getIndex3,
+      validateAll,
+      validateFields,
+      ruleCache
+    ]
+  );
+  return helpers;
+}
+
+// src/hooks/useForm.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function useForm(schema, {
+  arrayIdentifiers,
+  onFormSubmit: onFormSubmitProp,
+  resetOnSubmit = false,
+  keepValues: keepValuesProp
+} = DEFAULT_OPTIONS) {
+  const {
+    state,
+    setState,
+    metadata,
+    setMetadata,
+    stateRef,
+    metadataRef,
+    propsCache,
+    indexMapRef,
+    initialState,
+    validationSchema
+  } = useFormState(schema, arrayIdentifiers);
+  useComponentLanguage();
+  const ruleCache = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
+  (0, import_react6.useMemo)(() => {
+    ruleCache.current.clear();
+  }, [validationSchema]);
+  const getIndexFn = (0, import_react6.useCallback)(
+    (arrayKey, itemId) => getIndex(arrayKey, itemId, indexMapRef.current),
+    [indexMapRef]
+  );
+  const { validateField, validateFields, validateAll } = useValidation(
+    validationSchema,
+    stateRef,
+    metadataRef,
+    setMetadata,
+    arrayIdentifiers,
+    ruleCache
+  );
+  const { on, handleFieldChange } = useHandlers(
+    stateRef,
+    setState,
+    metadataRef,
+    setMetadata,
+    validationSchema,
+    ruleCache,
+    propsCache,
+    getIndexFn,
+    validateField
   );
-  const onBlur = (0, import_react2.useCallback)(
+  const helpers = useFormHelpers(
+    stateRef,
+    setState,
+    setMetadata,
+    metadataRef,
+    arrayIdentifiers,
+    validationSchema,
+    getIndexFn,
+    validateAll,
+    validateFields,
+    ruleCache
+  );
+  const onBlur = (0, import_react6.useCallback)(
     (id) => {
+      const compositeKey = String(id);
       validateField(
-        String(id),
-        String(id),
-        String(id),
+        compositeKey,
+        compositeKey,
+        compositeKey,
         stateRef.current[id],
         stateRef.current
       );
       setMetadata((prev) => {
         const newMap = new Map(prev);
-        const current = newMap.get(String(id)) || {
+        const current = newMap.get(compositeKey) || {
           isTouched: false,
           isInvalid: false,
           errorMessage: ""
         };
-        newMap.set(String(id), { ...current, isTouched: true });
+        const label = current.label || resolveLabel(compositeKey);
+        newMap.set(compositeKey, {
+          ...current,
+          isTouched: true,
+          label
+        });
         return newMap;
       });
     },
-    [validateField]
+    [validateField, stateRef, setMetadata]
   );
-  const scalarOnFieldChange = (0, import_react2.useCallback)(
+  const scalarOnFieldChange = (0, import_react6.useCallback)(
     (id, value) => {
       const data = resolveFieldData(
         [id],
         stateRef.current,
-        getIndex,
-        getNestedValue
+        getIndexFn,
+        getNestedValue,
+        (p, s) => getRule(p, s, ruleCache.current),
+        validationSchema
       );
       if (data) handleFieldChange(data, value);
     },
-    [getIndex, handleFieldChange, getRule, validationSchema]
+    [stateRef, getIndexFn, validationSchema, ruleCache, handleFieldChange]
   );
-  const arrayItemChange = (0, import_react2.useCallback)(
+  const arrayItemChange = (0, import_react6.useCallback)(
     ({
       at: compositePath,
       id: itemId,
@@ -1089,28 +1270,31 @@ function useForm(schema, {
       const data = resolveFieldData(
         [compositePath, itemId],
         stateRef.current,
-        getIndex,
-        getNestedValue
+        getIndexFn,
+        getNestedValue,
+        (p, s) => getRule(p, s, ruleCache.current),
+        validationSchema
       );
       if (data) handleFieldChange(data, value);
     },
-    [getIndex, handleFieldChange, getRule, validationSchema]
+    [stateRef, getIndexFn, validationSchema, ruleCache, handleFieldChange]
   );
-  const scalarOnSelectionChange = (0, import_react2.useCallback)(
+  const scalarOnSelectionChange = (0, import_react6.useCallback)(
     (id, val) => {
+      const compositeKey = String(id);
       const fixed = typeof val === "string" || val === null ? val : Array.from(val);
-      let nextState = handleNestedChange({
+      const nextState = handleNestedChange({
         state: stateRef.current,
-        id,
+        id: compositeKey,
         value: fixed,
-        hasNestedValues: String(id).includes(".")
+        hasNestedValues: compositeKey.includes(".")
       });
       setState(nextState);
-      validateField(String(id), String(id), String(id), fixed, nextState);
+      validateField(compositeKey, compositeKey, compositeKey, fixed, nextState);
     },
-    [validateField]
+    [stateRef, setState, validateField]
   );
-  const arraySelectionChange = (0, import_react2.useCallback)(
+  const arraySelectionChange = (0, import_react6.useCallback)(
     ({
       at: compositePath,
       id: itemId,
@@ -1120,28 +1304,25 @@ function useForm(schema, {
       const data = resolveFieldData(
         [compositePath, itemId],
         stateRef.current,
-        getIndex,
-        getNestedValue
+        getIndexFn,
+        getNestedValue,
+        (p, s) => getRule(p, s, ruleCache.current),
+        validationSchema
       );
       if (data) handleFieldChange(data, fixed);
     },
-    [getIndex, handleFieldChange, getRule, validationSchema]
+    [stateRef, getIndexFn, validationSchema, ruleCache, handleFieldChange]
   );
-  const onFormSubmit = (0, import_react2.useCallback)(
+  const onFormSubmit = (0, import_react6.useCallback)(
     (fn) => async (e) => {
       e.preventDefault();
-      if (await validateAll()) return;
+      const { isValid } = await validateAll();
+      if (!isValid) return;
       fn(stateRef.current, e);
     },
-    [validateAll]
+    [validateAll, stateRef]
   );
-  const onFormSubmitPropRef = (0, import_react2.useRef)(onFormSubmitProp);
-  onFormSubmitPropRef.current = onFormSubmitProp;
-  const resetOnSubmitRef = (0, import_react2.useRef)(resetOnSubmit);
-  resetOnSubmitRef.current = resetOnSubmit;
-  const keepValuesPropRef = (0, import_react2.useRef)(keepValuesProp);
-  keepValuesPropRef.current = keepValuesProp;
-  const handleReset = (0, import_react2.useCallback)(
+  const handleReset = (0, import_react6.useCallback)(
     (options) => {
       const { keepValues } = options || {};
       if (keepValues && keepValues.length > 0) {
@@ -1156,18 +1337,23 @@ function useForm(schema, {
       }
       setMetadata(/* @__PURE__ */ new Map());
     },
-    [initialState]
+    [initialState, stateRef, setState, setMetadata]
   );
-  const validateAllRef = (0, import_react2.useRef)(validateAll);
+  const onFormSubmitPropRef = (0, import_react6.useRef)(onFormSubmitProp);
+  onFormSubmitPropRef.current = onFormSubmitProp;
+  const resetOnSubmitRef = (0, import_react6.useRef)(resetOnSubmit);
+  resetOnSubmitRef.current = resetOnSubmit;
+  const keepValuesPropRef = (0, import_react6.useRef)(keepValuesProp);
+  keepValuesPropRef.current = keepValuesProp;
+  const validateAllRef = (0, import_react6.useRef)(validateAll);
   validateAllRef.current = validateAll;
-  const ControlledForm = (0, import_react2.useMemo)(() => {
+  const ControlledForm = (0, import_react6.useMemo)(() => {
     return (props) => {
       const { onSubmit, ...rest } = props;
       const handleSubmit = async (e) => {
         e.preventDefault();
-        if (await validateAllRef.current()) {
-          return;
-        }
+        const { isValid } = await validateAllRef.current();
+        if (!isValid) return;
         onFormSubmitPropRef.current?.(stateRef.current, e);
         if (resetOnSubmitRef.current) {
           handleReset({ keepValues: keepValuesPropRef.current });
@@ -1175,18 +1361,16 @@ function useForm(schema, {
         onSubmit?.(stateRef.current, e);
       };
       return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-        import_react3.Form,
+        import_react7.Form,
         {
-          style: {
-            display: "contents"
-          },
+          style: { display: "contents" },
           onSubmit: handleSubmit,
           ...rest
         }
       );
     };
-  }, []);
-  return (0, import_react2.useMemo)(
+  }, [handleReset, stateRef]);
+  return (0, import_react6.useMemo)(
     () => ({
       state,
       setState,
@@ -1201,6 +1385,8 @@ function useForm(schema, {
       isDirty: Array.from(metadata.values()).some((m) => m.isTouched),
       onFormReset: handleReset,
       onFormSubmit,
+      validateAll,
+      validateFields,
       ControlledForm
     }),
     [
@@ -1215,9 +1401,10 @@ function useForm(schema, {
       scalarOnSelectionChange,
       arraySelectionChange,
       validateAll,
+      validateFields,
       onFormSubmit,
       ControlledForm,
-      initialState
+      handleReset
     ]
   );
 }