@juantroconisf/lib 10.0.0 → 11.0.1

package/README.md

@@ -192,12 +192,12 @@ All methods support both **scalar/nested** paths and **array item** paths (compo
 
 For updating state outside of a component (e.g. in an event handler, after an API call), use the manual functions returned by `useForm`.
 
-| Function                 | Use for                         | Signature                        |
-| ------------------------ | ------------------------------- | -------------------------------- |
-| `onFieldChange`          | Scalar / nested object field    | `(id, value)`                    |
-| `onArrayItemChange`      | Object array item field         | `("array.field", itemId, value)` |
-| `onSelectionChange`      | Scalar / nested selection field | `(id, value)`                    |
-| `onArraySelectionChange` | Array item selection field      | `("array.field", itemId, value)` |
+| Function                 | Use for                         | Signature             |
+| ------------------------ | ------------------------------- | --------------------- |
+| `onFieldChange`          | Scalar / nested object field    | `(id, value)`         |
+| `onArrayItemChange`      | Object array item field         | `({ at, id, value })` |
+| `onSelectionChange`      | Scalar / nested selection field | `(id, value)`         |
+| `onArraySelectionChange` | Array item selection field      | `({ at, id, value })` |
 
 ```ts
 const { onFieldChange, onArrayItemChange, onSelectionChange } = useForm(schema);
@@ -206,13 +206,13 @@ const { onFieldChange, onArrayItemChange, onSelectionChange } = useForm(schema);
 onFieldChange("email", "user@example.com");
 
 // Update a field inside an array item
-onArrayItemChange("users.name", userId, "Alice");
+onArrayItemChange({ at: "users.name", id: userId, value: "Alice" });
 
-// Update a selection field
-onSelectionChange("theme", "dark");
+// Update a selection field inside an array item
+onArraySelectionChange({ at: "users.role", id: userId, value: "admin" });
 ```
 
-> **Note:** `onFieldChange` only handles scalar and nested object paths. Use `onArrayItemChange` for array items — they each have a unique signature so TypeScript will guide you.
+> **`at`** is the composite dot-notation path (`"array.field"`), **`id`** is the item's unique identifier, **`value`** is the new value to set. These are direct setters — call them imperatively, not as event listeners.
 
 ---
 
@@ -220,16 +220,16 @@ onSelectionChange("theme", "dark");
 
 Extracted from `helpers` on the `useForm` return value. Items in object arrays are tracked by ID (default field: `id`).
 
-| Method                               | Description                                        |
-| ------------------------------------ | -------------------------------------------------- |
-| `addItem(path, item, index?)`        | Adds an item to the end (or at `index`)            |
-| `removeItem(path, index)`            | Removes by index                                   |
-| `removeById(path, id)`               | Removes by item ID                                 |
-| `updateItem(path, index, partial)`   | Partially updates an item by index (shallow merge) |
-| `updateById(path, id, partial)`      | Partially updates an item by ID (shallow merge)    |
-| `moveItem(path, fromIndex, toIndex)` | Reorders by index                                  |
-| `moveById(path, fromId, toId)`       | Reorders by ID                                     |
-| `getItem(path, id)`                  | O(1) lookup by ID                                  |
+| Method                                      | Description                                        |
+| ------------------------------------------- | -------------------------------------------------- |
+| `addItem(path, item, index?)`               | Adds an item to the end (or at `index`)            |
+| `removeItemByIndexByIndex(path, index)`     | Removes by index                                   |
+| `removeById(path, id)`                      | Removes by item ID                                 |
+| `updateByIndex(path, index, partial)`       | Partially updates an item by index (shallow merge) |
+| `updateById(path, id, partial)`             | Partially updates an item by ID (shallow merge)    |
+| `moveItemByIndex(path, fromIndex, toIndex)` | Reorders by index                                  |
+| `moveById(path, fromId, toId)`              | Reorders by ID                                     |
+| `getItemById(path, id)`                     | O(1) lookup by ID                                  |
 
 ```ts
 const { helpers } = useForm(schema);
@@ -242,19 +242,65 @@ helpers.moveById("users", 123, 456); // moves item 123 to where item 456 is
 
 ### Custom Array Identifier
 
-If your array items don't use an `id` field, specify the key via `arrayIdentifiers`:
+By default, the library tracks array items by their `id` field. If your items use a different field (e.g. `uuid`, `slug`, `code`), configure it via `arrayIdentifiers` in the options.
 
 ```ts
-const { helpers } = useForm(
+const { on, helpers, onArrayItemChange } = useForm(
   {
     employees: array()
-      .of(object({ uuid: string(), name: string() }))
+      .of(
+        object({
+          uuid: string().required(),
+          name: string().required(),
+          role: string().required(),
+        }),
+      )
       .default([]),
   },
-  { arrayIdentifiers: { employees: "uuid" } },
+  {
+    arrayIdentifiers: {
+      employees: "uuid", // tells the library to use `uuid` instead of `id`
+    },
+  },
 );
+```
+
+**Every ID-based function picks this up automatically:**
+
+```ts
+// on.* bindings — the second arg is the item identifier
+<Input {...on.input("employees.name", employee.uuid)} label="Name" />
+<Select {...on.select("employees.role", employee.uuid)} label="Role">...</Select>
+
+// Manual setters — `id` is the item identifier
+onArrayItemChange({ at: "employees.name", id: employee.uuid, value: "Alice" });
+onArraySelectionChange({ at: "employees.role", id: employee.uuid, value: "admin" });
+
+// Helpers — all `*ById` methods use the configured identifier
+helpers.removeById("employees", employee.uuid);
+helpers.updateById("employees", employee.uuid, { name: "Alice" });   // partial update
+helpers.moveById("employees", fromUuid, toUuid);
+helpers.getItemById("employees", employee.uuid);
+```
 
-helpers.removeById("employees", "some-uuid-string");
+> The identifier field you configure must be a **scalar** (string or number) present in every item. The library uses it to build an internal O(1) index map, which is why array operations are fast regardless of list size.
+
+**Type inference:** `arrayIdentifiers` is typed so only valid scalar keys of each array element are accepted:
+
+```ts
+// ✅ uuid is a string field on each employee
+{
+  arrayIdentifiers: {
+    employees: "uuid";
+  }
+}
+
+// ❌ TypeScript error — name is not a valid identifier (may not be unique)
+{
+  arrayIdentifiers: {
+    employees: "name";
+  }
+} // error if "name" is not in type
 ```
 
 ---

package/dist/index.d.mts

@@ -92,7 +92,7 @@ interface ItemNumberInputProps extends ComponentInputProps {
 /** Props returned by on.select() */
 interface ItemSelectProps extends ComponentInputProps {
     onSelectionChange: NonNullable<SelectProps["onSelectionChange"]>;
-    selectedKeys: string[] | number[] | string | null;
+    selectedKeys: NonNullable<SelectProps["selectedKeys"]>;
 }
 /** Props returned by on.autocomplete() */
 interface ItemAutocompleteProps extends ComponentInputProps {
@@ -164,16 +164,30 @@ type ObjectArrayFieldPaths<O extends StateType> = {
     [K in keyof O]: O[K] extends Record<string, any>[] ? `${K & string}.${FieldPaths<ArrayElement<O[K]>>}` : never;
 }[keyof O];
 type ArrayElement<T> = T extends (infer E)[] ? E : never;
+/** Resolves the type of the identifier field for an array element (defaults to "id"). */
+type ItemIdType<O extends StateType, K extends keyof O> = "id" extends keyof ArrayElement<O[K]> ? ArrayElement<O[K]>["id"] : string | number;
+/** Extracts the array key from a composite path e.g. "relatives.age" → "relatives". */
+type ExtractArrayKey<P extends string> = P extends `${infer K}.${string}` ? K : never;
+/**
+ * Resolves the identifier field type for the array referenced by a composite path.
+ * e.g. if relatives[].id is string, then ArrayItemIdTypeFromPath<O, "relatives.age"> = string
+ */
+type ArrayItemIdTypeFromPath<O extends StateType, P extends string> = ExtractArrayKey<P> extends keyof O ? ItemIdType<O, ExtractArrayKey<P>> : string | number;
+/**
+ * Resolves the value type for the field referenced by a composite path.
+ * e.g. "relatives.age" → number (the type of the `age` field in each relative item)
+ */
+type CompositeFieldValue<O extends StateType, P extends string> = P extends `${infer K}.${infer F}` ? K extends keyof O ? O[K] extends (infer E)[] ? F extends keyof E ? NonNullable<E[F]> : any : any : any : any;
 type NestedFieldValue<T, F extends string> = F extends `${infer First}.${infer Rest}` ? First extends keyof T ? NestedFieldValue<NonNullable<T[First]>, Rest> : NonNullable<T> extends (infer U)[] ? NestedFieldValue<U, F> : any : F extends keyof T ? NonNullable<T[F]> : NonNullable<T> extends (infer U)[] ? F extends keyof U ? NonNullable<U[F]> : any : any;
 type FieldPaths<T> = T extends Record<string, any> ? {
     [K in keyof T & string]: T[K] extends any[] ? K : T[K] extends Record<string, any> ? `${K}.${FieldPaths<T[K]>}` : K;
 }[keyof T & string] : never;
 type NestedObjectPaths<O extends StateType> = {
-    [K in keyof O & string]: O[K] extends any[] ? never : O[K] extends Record<string, any> ? `${K}.${FieldPaths<O[K]>}` : never;
+    [K in keyof O & string]: NonNullable<O[K]> extends any[] ? never : NonNullable<O[K]> extends Date ? never : NonNullable<O[K]> extends Record<string, any> ? `${K}.${FieldPaths<NonNullable<O[K]>>}` : never;
 }[keyof O & string];
-/** Keys whose values are not arrays and not plain objects (i.e. scalar/primitive fields). */
+/** Keys whose values are not arrays and not plain objects (i.e. scalar/primitive fields). Date is treated as a scalar. */
 type ScalarKeys<O extends StateType> = {
-    [K in keyof O]: O[K] extends any[] ? never : O[K] extends Record<string, any> ? never : K;
+    [K in keyof O]: NonNullable<O[K]> extends any[] ? never : NonNullable<O[K]> extends Date ? K : NonNullable<O[K]> extends Record<string, any> ? never : K;
 }[keyof O];
 type AllPaths<O extends StateType> = ScalarKeys<O> | NestedObjectPaths<O>;
 /**
@@ -183,19 +197,19 @@ interface HelpersFunc<O extends StateType> {
     /** Adds a new item to an array. */
     addItem: <K extends ArrayPaths<O>>(arrayKey: K, item: NestedFieldValue<O, K> extends (infer E)[] ? E : never, index?: number) => void;
     /** Removes an item from an array by its index. */
-    removeItem: <K extends ArrayPaths<O>>(arrayKey: K, index: number) => void;
+    removeItemByIndexByIndex: <K extends ArrayPaths<O>>(arrayKey: K, index: number) => void;
     /** Removes an item from an array by its unique identifier. */
     removeById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => void;
     /** Updates an item in an array at the given index (supports partial updates). */
-    updateItem: <K extends ArrayPaths<O>>(arrayKey: K, index: number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
+    updateByIndex: <K extends ArrayPaths<O>>(arrayKey: K, index: number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
     /** Updates an item in an array by its unique identifier (supports partial updates). */
     updateById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
     /** Moves an item within an array using indices. */
-    moveItem: <K extends ArrayPaths<O>>(arrayKey: K, from: number, to: number) => void;
+    moveItemByIndex: <K extends ArrayPaths<O>>(arrayKey: K, from: number, to: number) => void;
     /** Moves an item within an array using unique identifiers. */
     moveById: <K extends ArrayPaths<O>>(arrayKey: K, fromId: string | number, toId: string | number) => void;
     /** Gets an item from an array by its unique identifier (O(1) via indexMap). */
-    getItem: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => (NestedFieldValue<O, K> extends (infer E)[] ? E : never) | undefined;
+    getItemById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => (NestedFieldValue<O, K> extends (infer E)[] ? E : never) | undefined;
 }
 /**
  * The response object from the useForm hook.
@@ -205,12 +219,26 @@ interface UseFormResponse<O extends StateType> {
     onFieldBlur: BlurFunc<O>;
     /** Updates a scalar or nested object field. */
     onFieldChange<P extends AllPaths<O>>(id: P, value: NestedFieldValue<O, P & string>): void;
-    /** Manually updates a field within an object array item using "array.field" composite path. */
-    onArrayItemChange<P extends ObjectArrayFieldPaths<O>>(compositePath: P, itemId: string | number, value: any): void;
+    /** Manually updates a field within an object array item. */
+    onArrayItemChange<P extends ObjectArrayFieldPaths<O>>(options: {
+        /** Composite dot-notation path: e.g. "users.name" */
+        at: P;
+        /** The unique identifier of the target array item — type is inferred from the array element's id field. */
+        id: ArrayItemIdTypeFromPath<O, P & string>;
+        /** The new value — type is inferred from the field referenced by `at`. */
+        value: CompositeFieldValue<O, P & string>;
+    }): void;
     /** Manually updates a scalar or nested object selection field. */
     onSelectionChange: ValueChangeFunc<O, keyof O>;
     /** Manually updates a selection-based field within an object array item. */
-    onArraySelectionChange<P extends ObjectArrayFieldPaths<O>>(compositePath: P, itemId: string | number, value: any): void;
+    onArraySelectionChange<P extends ObjectArrayFieldPaths<O>>(options: {
+        /** Composite dot-notation path: e.g. "users.role" */
+        at: P;
+        /** The unique identifier of the target array item — type is inferred from the array element's id field. */
+        id: ArrayItemIdTypeFromPath<O, P & string>;
+        /** The new selection value — type is inferred from the field referenced by `at`. */
+        value: CompositeFieldValue<O, P & string>;
+    }): void;
     state: O;
     setState: React.Dispatch<React.SetStateAction<O>>;
     metadata: MetadataType;
@@ -240,4 +268,4 @@ interface UseFormResponse<O extends StateType> {
 
 declare function useForm<S extends Record<string, ConfigType>>(schema: S, { arrayIdentifiers, onFormSubmit: onFormSubmitProp, resetOnSubmit, keepValues: keepValuesProp, }?: FormOptions<InferState<S>>): UseFormResponse<InferState<S>>;
 
-export { type BlurFunc, type ConfigType, type FieldMetadata, type FormOptions, type FormSubmitHandler, type HelpersFunc, type InferState, type InferSubmitHandler, type MetadataType, type NestedChangeProps, NextUIError, type OnMethods, type StateType, type UseFormResponse, type ValueChangeFunc, useForm };
+export { type BlurFunc, type ComponentInputProps, type ConfigType, type FieldMetadata, type FormOptions, type FormResetOptions, type FormSubmitHandler, type HelpersFunc, type InferState, type InferSubmitHandler, type ItemAutocompleteProps, type ItemInputProps, type ItemNumberInputProps, type ItemRadioGroupProps, type ItemSelectProps, type ItemToggleProps, type MetadataType, type NestedChangeProps, NextUIError, type OnMethods, type StateType, type UseFormResponse, type ValueChangeFunc, useForm };

package/dist/index.d.ts

@@ -92,7 +92,7 @@ interface ItemNumberInputProps extends ComponentInputProps {
 /** Props returned by on.select() */
 interface ItemSelectProps extends ComponentInputProps {
     onSelectionChange: NonNullable<SelectProps["onSelectionChange"]>;
-    selectedKeys: string[] | number[] | string | null;
+    selectedKeys: NonNullable<SelectProps["selectedKeys"]>;
 }
 /** Props returned by on.autocomplete() */
 interface ItemAutocompleteProps extends ComponentInputProps {
@@ -164,16 +164,30 @@ type ObjectArrayFieldPaths<O extends StateType> = {
     [K in keyof O]: O[K] extends Record<string, any>[] ? `${K & string}.${FieldPaths<ArrayElement<O[K]>>}` : never;
 }[keyof O];
 type ArrayElement<T> = T extends (infer E)[] ? E : never;
+/** Resolves the type of the identifier field for an array element (defaults to "id"). */
+type ItemIdType<O extends StateType, K extends keyof O> = "id" extends keyof ArrayElement<O[K]> ? ArrayElement<O[K]>["id"] : string | number;
+/** Extracts the array key from a composite path e.g. "relatives.age" → "relatives". */
+type ExtractArrayKey<P extends string> = P extends `${infer K}.${string}` ? K : never;
+/**
+ * Resolves the identifier field type for the array referenced by a composite path.
+ * e.g. if relatives[].id is string, then ArrayItemIdTypeFromPath<O, "relatives.age"> = string
+ */
+type ArrayItemIdTypeFromPath<O extends StateType, P extends string> = ExtractArrayKey<P> extends keyof O ? ItemIdType<O, ExtractArrayKey<P>> : string | number;
+/**
+ * Resolves the value type for the field referenced by a composite path.
+ * e.g. "relatives.age" → number (the type of the `age` field in each relative item)
+ */
+type CompositeFieldValue<O extends StateType, P extends string> = P extends `${infer K}.${infer F}` ? K extends keyof O ? O[K] extends (infer E)[] ? F extends keyof E ? NonNullable<E[F]> : any : any : any : any;
 type NestedFieldValue<T, F extends string> = F extends `${infer First}.${infer Rest}` ? First extends keyof T ? NestedFieldValue<NonNullable<T[First]>, Rest> : NonNullable<T> extends (infer U)[] ? NestedFieldValue<U, F> : any : F extends keyof T ? NonNullable<T[F]> : NonNullable<T> extends (infer U)[] ? F extends keyof U ? NonNullable<U[F]> : any : any;
 type FieldPaths<T> = T extends Record<string, any> ? {
     [K in keyof T & string]: T[K] extends any[] ? K : T[K] extends Record<string, any> ? `${K}.${FieldPaths<T[K]>}` : K;
 }[keyof T & string] : never;
 type NestedObjectPaths<O extends StateType> = {
-    [K in keyof O & string]: O[K] extends any[] ? never : O[K] extends Record<string, any> ? `${K}.${FieldPaths<O[K]>}` : never;
+    [K in keyof O & string]: NonNullable<O[K]> extends any[] ? never : NonNullable<O[K]> extends Date ? never : NonNullable<O[K]> extends Record<string, any> ? `${K}.${FieldPaths<NonNullable<O[K]>>}` : never;
 }[keyof O & string];
-/** Keys whose values are not arrays and not plain objects (i.e. scalar/primitive fields). */
+/** Keys whose values are not arrays and not plain objects (i.e. scalar/primitive fields). Date is treated as a scalar. */
 type ScalarKeys<O extends StateType> = {
-    [K in keyof O]: O[K] extends any[] ? never : O[K] extends Record<string, any> ? never : K;
+    [K in keyof O]: NonNullable<O[K]> extends any[] ? never : NonNullable<O[K]> extends Date ? K : NonNullable<O[K]> extends Record<string, any> ? never : K;
 }[keyof O];
 type AllPaths<O extends StateType> = ScalarKeys<O> | NestedObjectPaths<O>;
 /**
@@ -183,19 +197,19 @@ interface HelpersFunc<O extends StateType> {
     /** Adds a new item to an array. */
     addItem: <K extends ArrayPaths<O>>(arrayKey: K, item: NestedFieldValue<O, K> extends (infer E)[] ? E : never, index?: number) => void;
     /** Removes an item from an array by its index. */
-    removeItem: <K extends ArrayPaths<O>>(arrayKey: K, index: number) => void;
+    removeItemByIndexByIndex: <K extends ArrayPaths<O>>(arrayKey: K, index: number) => void;
     /** Removes an item from an array by its unique identifier. */
     removeById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => void;
     /** Updates an item in an array at the given index (supports partial updates). */
-    updateItem: <K extends ArrayPaths<O>>(arrayKey: K, index: number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
+    updateByIndex: <K extends ArrayPaths<O>>(arrayKey: K, index: number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
     /** Updates an item in an array by its unique identifier (supports partial updates). */
     updateById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number, value: NestedFieldValue<O, K> extends (infer E)[] ? Partial<E> : never) => void;
     /** Moves an item within an array using indices. */
-    moveItem: <K extends ArrayPaths<O>>(arrayKey: K, from: number, to: number) => void;
+    moveItemByIndex: <K extends ArrayPaths<O>>(arrayKey: K, from: number, to: number) => void;
     /** Moves an item within an array using unique identifiers. */
     moveById: <K extends ArrayPaths<O>>(arrayKey: K, fromId: string | number, toId: string | number) => void;
     /** Gets an item from an array by its unique identifier (O(1) via indexMap). */
-    getItem: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => (NestedFieldValue<O, K> extends (infer E)[] ? E : never) | undefined;
+    getItemById: <K extends ArrayPaths<O>>(arrayKey: K, itemId: string | number) => (NestedFieldValue<O, K> extends (infer E)[] ? E : never) | undefined;
 }
 /**
  * The response object from the useForm hook.
@@ -205,12 +219,26 @@ interface UseFormResponse<O extends StateType> {
     onFieldBlur: BlurFunc<O>;
     /** Updates a scalar or nested object field. */
     onFieldChange<P extends AllPaths<O>>(id: P, value: NestedFieldValue<O, P & string>): void;
-    /** Manually updates a field within an object array item using "array.field" composite path. */
-    onArrayItemChange<P extends ObjectArrayFieldPaths<O>>(compositePath: P, itemId: string | number, value: any): void;
+    /** Manually updates a field within an object array item. */
+    onArrayItemChange<P extends ObjectArrayFieldPaths<O>>(options: {
+        /** Composite dot-notation path: e.g. "users.name" */
+        at: P;
+        /** The unique identifier of the target array item — type is inferred from the array element's id field. */
+        id: ArrayItemIdTypeFromPath<O, P & string>;
+        /** The new value — type is inferred from the field referenced by `at`. */
+        value: CompositeFieldValue<O, P & string>;
+    }): void;
     /** Manually updates a scalar or nested object selection field. */
     onSelectionChange: ValueChangeFunc<O, keyof O>;
     /** Manually updates a selection-based field within an object array item. */
-    onArraySelectionChange<P extends ObjectArrayFieldPaths<O>>(compositePath: P, itemId: string | number, value: any): void;
+    onArraySelectionChange<P extends ObjectArrayFieldPaths<O>>(options: {
+        /** Composite dot-notation path: e.g. "users.role" */
+        at: P;
+        /** The unique identifier of the target array item — type is inferred from the array element's id field. */
+        id: ArrayItemIdTypeFromPath<O, P & string>;
+        /** The new selection value — type is inferred from the field referenced by `at`. */
+        value: CompositeFieldValue<O, P & string>;
+    }): void;
     state: O;
     setState: React.Dispatch<React.SetStateAction<O>>;
     metadata: MetadataType;
@@ -240,4 +268,4 @@ interface UseFormResponse<O extends StateType> {
 
 declare function useForm<S extends Record<string, ConfigType>>(schema: S, { arrayIdentifiers, onFormSubmit: onFormSubmitProp, resetOnSubmit, keepValues: keepValuesProp, }?: FormOptions<InferState<S>>): UseFormResponse<InferState<S>>;
 
-export { type BlurFunc, type ConfigType, type FieldMetadata, type FormOptions, type FormSubmitHandler, type HelpersFunc, type InferState, type InferSubmitHandler, type MetadataType, type NestedChangeProps, NextUIError, type OnMethods, type StateType, type UseFormResponse, type ValueChangeFunc, useForm };
+export { type BlurFunc, type ComponentInputProps, type ConfigType, type FieldMetadata, type FormOptions, type FormResetOptions, type FormSubmitHandler, type HelpersFunc, type InferState, type InferSubmitHandler, type ItemAutocompleteProps, type ItemInputProps, type ItemNumberInputProps, type ItemRadioGroupProps, type ItemSelectProps, type ItemToggleProps, type MetadataType, type NestedChangeProps, NextUIError, type OnMethods, type StateType, type UseFormResponse, type ValueChangeFunc, useForm };

package/dist/index.js

@@ -752,7 +752,7 @@ function useForm(schema, {
           });
         });
       },
-      removeItem: (arrayKey, index) => {
+      removeItemByIndexByIndex: (arrayKey, index) => {
         const currentArr = getNestedValue(stateRef.current, arrayKey) || [];
         const item = currentArr[index];
         const idKey = arrayIdentifiers?.[arrayKey] || "id";
@@ -789,7 +789,7 @@ function useForm(schema, {
           setMetadata((prev) => removeCompositeKeysByPrefix(prev, prefix));
         }
       },
-      updateItem: (arrayKey, index, value) => {
+      updateByIndex: (arrayKey, index, value) => {
         setState((prev) => {
           const arr = [...getNestedValue(prev, arrayKey) || []];
           arr[index] = typeof arr[index] === "object" && typeof value === "object" ? { ...arr[index], ...value } : value;
@@ -816,7 +816,7 @@ function useForm(schema, {
           });
         }
       },
-      moveItem: (arrayKey, from, to) => {
+      moveItemByIndex: (arrayKey, from, to) => {
         setState((prev) => {
           const arr = [...getNestedValue(prev, arrayKey) || []];
           const [item] = arr.splice(from, 1);
@@ -846,7 +846,7 @@ function useForm(schema, {
           });
         }
       },
-      getItem: (arrayKey, itemId) => {
+      getItemById: (arrayKey, itemId) => {
         const index = getIndex(arrayKey, itemId);
         if (index === void 0) return void 0;
         return getNestedValue(stateRef.current, arrayKey)[index];
@@ -889,7 +889,11 @@ function useForm(schema, {
     [getIndex, handleFieldChange]
   );
   const arrayItemChange = (0, import_react2.useCallback)(
-    (compositePath, itemId, value) => {
+    ({
+      at: compositePath,
+      id: itemId,
+      value
+    }) => {
       const data = resolveFieldData(
         [compositePath, itemId],
         stateRef.current,
@@ -915,7 +919,11 @@ function useForm(schema, {
     [validateField]
   );
   const arraySelectionChange = (0, import_react2.useCallback)(
-    (compositePath, itemId, val) => {
+    ({
+      at: compositePath,
+      id: itemId,
+      value: val
+    }) => {
       const fixed = typeof val === "string" || val === null ? val : Array.from(val);
       const data = resolveFieldData(
         [compositePath, itemId],

package/dist/index.mjs

@@ -726,7 +726,7 @@ function useForm(schema, {
           });
         });
       },
-      removeItem: (arrayKey, index) => {
+      removeItemByIndexByIndex: (arrayKey, index) => {
         const currentArr = getNestedValue(stateRef.current, arrayKey) || [];
         const item = currentArr[index];
         const idKey = arrayIdentifiers?.[arrayKey] || "id";
@@ -763,7 +763,7 @@ function useForm(schema, {
           setMetadata((prev) => removeCompositeKeysByPrefix(prev, prefix));
         }
       },
-      updateItem: (arrayKey, index, value) => {
+      updateByIndex: (arrayKey, index, value) => {
         setState((prev) => {
           const arr = [...getNestedValue(prev, arrayKey) || []];
           arr[index] = typeof arr[index] === "object" && typeof value === "object" ? { ...arr[index], ...value } : value;
@@ -790,7 +790,7 @@ function useForm(schema, {
           });
         }
       },
-      moveItem: (arrayKey, from, to) => {
+      moveItemByIndex: (arrayKey, from, to) => {
         setState((prev) => {
           const arr = [...getNestedValue(prev, arrayKey) || []];
           const [item] = arr.splice(from, 1);
@@ -820,7 +820,7 @@ function useForm(schema, {
           });
         }
       },
-      getItem: (arrayKey, itemId) => {
+      getItemById: (arrayKey, itemId) => {
         const index = getIndex(arrayKey, itemId);
         if (index === void 0) return void 0;
         return getNestedValue(stateRef.current, arrayKey)[index];
@@ -863,7 +863,11 @@ function useForm(schema, {
     [getIndex, handleFieldChange]
   );
   const arrayItemChange = useCallback(
-    (compositePath, itemId, value) => {
+    ({
+      at: compositePath,
+      id: itemId,
+      value
+    }) => {
       const data = resolveFieldData(
         [compositePath, itemId],
         stateRef.current,
@@ -889,7 +893,11 @@ function useForm(schema, {
     [validateField]
   );
   const arraySelectionChange = useCallback(
-    (compositePath, itemId, val) => {
+    ({
+      at: compositePath,
+      id: itemId,
+      value: val
+    }) => {
       const fixed = typeof val === "string" || val === null ? val : Array.from(val);
       const data = resolveFieldData(
         [compositePath, itemId],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juantroconisf/lib",
-  "version": "10.0.0",
+  "version": "11.0.1",
   "description": "A form validation library for HeroUI.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",