react-form-manage 1.0.8-beta.26 → 1.0.8-beta.28

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.8-beta.28] - 2026-02-09
+
+### Features
+
+- **Deep Trigger Set Value**: Implement recursive value setting with comprehensive listener triggering
+  - `setFieldValue` with `deepTrigger: true` option for recursive listener notification
+  - Support for plain objects, arrays, FormLists, and nested structures
+  - Proper cleanup for removed fields and array items
+  - Edge case handling: removed object fields, nested FormList items
+- **Enhanced setFieldValues**: Improved batch value setting logic
+  - Automatically detects arrays and uses deep trigger
+  - Traverses object structure and stops at arrays
+  - Primitives trigger onChange, arrays use handleDeepTriggerSet
+- **Utility Functions**: New path collection utilities in obj.util.ts
+  - `getAllPathsIncludingContainers`: Get all paths including intermediate containers
+  - `getAllPathsStopAtArray`: Get paths but stop traversal at arrays
+- **Array Index Notation**: Changed from `[index]` to `.index` notation for consistency
+- **Documentation**: Added comprehensive DEEP_TRIGGER_LOGIC.md with 6 detailed case studies
+- **Test Suite**: Created 10 test cases covering all deep trigger scenarios
+
+### Technical Details
+
+- Deep trigger handles 5 core value types: primitives, plain objects, array listeners (FormList), non-listener arrays, and class instances
+- Hierarchical trigger order: field level → item/index level → property level
+- Recursive cleanup for removed nested structures
+- Options support for controlling dirty state triggering
+
+## [1.0.8-beta.27] - 2026-02-04
+
+### Features
+
+- Add `useWatchNormalize` hook for watching and normalizing form data
+- Support custom normalization functions for automatic value transformation
+- Simplifies data format conversion during form value watching
+
 ## [1.0.8-beta.25] - 2026-02-04
 
 ### Changes

package/dist/constants/form.d.ts

@@ -4,4 +4,4 @@ export declare const SUBMIT_STATE: {
     readonly SUBMITTED: "submitted";
     readonly REJECTED: "rejected";
 };
-export type SubmitState = typeof SUBMIT_STATE[keyof typeof SUBMIT_STATE];
+export type SubmitState = (typeof SUBMIT_STATE)[keyof typeof SUBMIT_STATE];

package/dist/hooks/useFormItemControl.d.ts

@@ -1,7 +1,6 @@
 import { type RefObject } from "react";
 import type { FormInstance } from "../stores/formStore";
 import type { FormFieldError, SubmitState, ValidationRule } from "../types/public";
-type AnyObject = Record<string, any>;
 interface UseFormItemControlProps {
     formName?: string;
     form?: FormInstance;
@@ -13,9 +12,13 @@ interface UseFormItemControlProps {
     hidden?: boolean;
     collectOnHidden?: boolean;
 }
+export interface OnChangeOptions {
+    notTriggerDirty?: boolean;
+    initiedData?: boolean;
+}
 export interface UseFormItemControlReturn {
     value: any;
-    onChange: (value: any, options?: AnyObject) => void;
+    onChange: (value: any, options?: OnChangeOptions) => void;
     state: any;
     errors: FormFieldError[];
     onFocus: () => void;

package/dist/providers/Form.d.ts

@@ -1,8 +1,12 @@
 import type { ComponentType, FormHTMLAttributes, ReactNode } from "react";
 import FormItem from "../components/Form/FormItem";
+import { OnChangeOptions } from "../hooks/useFormItemControl";
 import type { PublicFormInstance, UseFormItemStateWatchReturn } from "../types/public";
-export type { FormFieldError, SubmitState, UseFormItemStateWatchReturn, ValidationRule, } from "../types/public";
+export type { FormFieldError, SubmitState, UseFormItemStateWatchReturn, ValidationRule } from "../types/public";
 export declare const FormContext: import("react").Context<any>;
+export interface SetFieldValueOptions extends OnChangeOptions {
+    deepTrigger?: boolean;
+}
 export interface FormProps<T = any> extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
     collectHiddenFields?: boolean;
     children: ReactNode;
@@ -22,6 +26,7 @@ declare namespace Form {
     var useForm: typeof import("./Form").useForm;
     var Item: typeof FormItem;
     var useWatch: typeof import("./Form").useWatch;
+    var useWatchNormalized: typeof import("./Form").useWatchNormalized;
     var useSubmitDataWatch: typeof import("./Form").useSubmitDataWatch;
     var useFormStateWatch: <T = any>(formNameOrFormInstance?: string | PublicFormInstance<T>) => any;
     var useFormItemStateWatch: <T = any>(nameOrFormItemId: string, formNameOrFormInstance?: string | PublicFormInstance<T>) => UseFormItemStateWatchReturn;
@@ -30,6 +35,11 @@ export default Form;
 export declare function useFormContext(): any;
 export declare function useForm<T = any>(formNameOrFormInstance?: string | PublicFormInstance<T>): PublicFormInstance<T>[];
 export declare function useWatch<T = any>(name: keyof T & string, formNameOrFormInstance?: string | PublicFormInstance<T>): T[keyof T] | undefined;
+export declare function useWatchNormalized<T, TFn extends (v: any) => any>({ name, normalizeFn, formNameOrFormInstance, }: {
+    name: keyof T & string;
+    normalizeFn: TFn;
+    formNameOrFormInstance?: string | PublicFormInstance<T>;
+}): ReturnType<TFn>;
 export declare function useSubmitDataWatch<T = any>({ formNameOrFormInstance, triggerWhenChange, mapFn, }: {
     formNameOrFormInstance?: string | PublicFormInstance<T>;
     triggerWhenChange?: boolean;

package/dist/providers/Form.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { cloneDeep, filter, get, isEqual, isNil, isPlainObject, last, set, uniqBy } from "lodash";
+import { cloneDeep, filter, get, isArray, isEqual, isNil, isPlainObject, last, set, uniqBy } from "lodash";
 import { useTask } from "minh-custom-hooks-release";
-import { createContext, useContext, useEffect, useState } from "react";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
 import { flushSync } from "react-dom";
 import { useShallow } from "zustand/react/shallow";
 import FormItem from "../components/Form/FormItem";
 import { SUBMIT_STATE } from "../constants/form";
 import { useFormStore } from "../stores/formStore";
-import { getAllNoneObjStringPath } from "../utils/obj.util";
+import { getAllNoneObjStringPath, getAllPathsIncludingContainers, getAllPathsStopAtArray } from "../utils/obj.util";
 const FormContext = createContext(null);
 function Form({ children, formName, initialValues, onFinish, onReject, onFinally, FormElement, collectHiddenFields: formCollectHiddenFields = true, ...props }) {
   const {
@@ -44,7 +44,137 @@ function Form({ children, formName, initialValues, onFinish, onReject, onFinally
       getListeners: state.getListeners
     };
   }));
+  const handlePrimitiveValue = (name, value, options) => {
+    const listener = getListeners().find((l) => l.name === name && l.formName === formName);
+    if (listener) {
+      listener.onChange(value, options);
+    } else {
+      setData(formName, name, value);
+    }
+  };
+  const handleArrayListener = (name, value, options, coreRecursive) => {
+    const listener = getListeners().find((l) => l.name === name && l.formName === formName);
+    if (!listener)
+      return;
+    const currentValue = getFormItemValue(formName, name);
+    if (!isEqual(currentValue, value)) {
+      listener.onArrayChange(value, options);
+      value.forEach((item, index) => {
+        const itemName = `${name}.${index}`;
+        const itemListener = getListeners().find((l) => l.name === itemName && l.formName === formName);
+        if (itemListener) {
+          itemListener.onChange(item, options);
+        }
+        const nestedPaths = getAllPathsIncludingContainers(item);
+        nestedPaths.forEach((p) => {
+          if (coreRecursive) {
+            coreRecursive(`${itemName}.${p}`, get(item, p), options);
+          }
+        });
+      });
+      if (isArray(currentValue) && currentValue.length > value.length) {
+        for (let index = value.length; index < currentValue.length; index++) {
+          const itemName = `${name}.${index}`;
+          if (coreRecursive) {
+            coreRecursive(itemName, void 0, options);
+          }
+        }
+      }
+    }
+  };
+  const handlePlainObject = (name, value, options, coreRecursive) => {
+    const listener = getListeners().find((l) => l.name === name && l.formName === formName);
+    if (listener && listener.type !== "array") {
+      listener.onChange(value, options);
+    }
+    const allPaths = getAllPathsIncludingContainers(value);
+    allPaths.forEach((p) => {
+      if (coreRecursive) {
+        const fullPath = `${name}.${p}`;
+        coreRecursive(fullPath, get(value, p), options);
+      }
+    });
+    const previousValue = getFieldValue(name);
+    if (isPlainObject(previousValue)) {
+      const previousKeys = Object.keys(previousValue);
+      const newKeys = Object.keys(value);
+      const removedKeys = previousKeys.filter((k) => !newKeys.includes(k));
+      removedKeys.forEach((key) => {
+        if (coreRecursive) {
+          coreRecursive(`${name}.${key}`, void 0, options);
+        }
+      });
+    }
+  };
+  const handleNonListenerArray = (name, value, options, coreRecursive) => {
+    const previousValues = getFieldValue(name);
+    if (isArray(previousValues)) {
+      if (previousValues.length !== value.length || !isEqual(previousValues, value)) {
+        setData(formName, name, value);
+      }
+      value.forEach((item, index) => {
+        if (!isEqual(previousValues[index], item)) {
+          const itemName = `${name}.${index}`;
+          const itemListener = getListeners().find((l) => l.name === itemName && l.formName === formName);
+          if (itemListener) {
+            itemListener.onChange(item, options);
+          }
+          const nestedPaths = getAllPathsIncludingContainers(item);
+          nestedPaths.forEach((p) => {
+            if (coreRecursive) {
+              coreRecursive(`${itemName}.${p}`, get(item, p), options);
+            }
+          });
+        }
+      });
+      if (previousValues.length > value.length) {
+        for (let index = value.length; index < previousValues.length; index++) {
+          const itemName = `${name}.${index}`;
+          const removedItem = previousValues[index];
+          const nestedPaths = getAllPathsIncludingContainers(removedItem);
+          nestedPaths.forEach((p) => {
+            if (coreRecursive) {
+              coreRecursive(`${itemName}.${p}`, void 0, options);
+            }
+          });
+          if (coreRecursive) {
+            coreRecursive(itemName, void 0, options);
+          }
+        }
+      }
+    }
+  };
+  const deepTriggerSetCore = (name, value, options) => {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+      handlePrimitiveValue(name, value, options);
+      return;
+    }
+    if (isPlainObject(value)) {
+      const listener = getListeners().find((l) => l.name === name && l.formName === formName);
+      handlePlainObject(name, value, options, deepTriggerSetCore);
+      return;
+    }
+    if (Array.isArray(value)) {
+      const listener = getListeners().find((l) => l.name === name && l.formName === formName);
+      if (listener && listener.type === "array") {
+        handleArrayListener(name, value, options, deepTriggerSetCore);
+      } else if (!listener) {
+        handleNonListenerArray(name, value, options, deepTriggerSetCore);
+      } else {
+        handlePlainObject(name, value, options, deepTriggerSetCore);
+      }
+      return;
+    }
+    handlePrimitiveValue(name, value, options);
+  };
+  const handleDeepTriggerSet = (name, value, options) => {
+    deepTriggerSetCore(name, value, options);
+  };
   const setFieldValue = (name, value, options) => {
+    if (options == null ? void 0 : options.deepTrigger) {
+      handleDeepTriggerSet(name, value, options);
+      return;
+    }
     const listener = getListeners().find((l) => l.name === name && l.formName === formName);
     if (listener) {
       if (listener.type === "array") {
@@ -64,52 +194,28 @@ function Form({ children, formName, initialValues, onFinish, onReject, onFinally
         listener.onChange(value, options);
       }
     } else {
-      if (isPlainObject(value) || Array.isArray(value)) {
-        const allStringPath = getAllNoneObjStringPath(value);
-        allStringPath.forEach((p) => {
-          const findListener = getListeners().find((l) => l.name === `${name}.${p}` && l.formName === formName);
-          if (findListener) {
-            findListener.onChange(get(value, p), options);
-          } else {
-            setData(formName, `${name}.${p}`, get(value, p));
-          }
-        });
-      } else {
-        setData(formName, name, value);
-      }
+      setData(formName, name, value);
     }
   };
   const setFieldValues = (values, options = { notTriggerDirty: false }) => {
-    const allStringPath = getAllNoneObjStringPath(values);
-    allStringPath.forEach((p) => {
-      const listener = getListeners().find((l) => l.name === p && l.formName === formName);
+    const allPaths = getAllPathsStopAtArray(values);
+    allPaths.forEach((path) => {
+      const pathValue = get(values, path);
+      if (Array.isArray(pathValue)) {
+        handleDeepTriggerSet(path, pathValue, options);
+        return;
+      }
+      const listener = getListeners().find((l) => l.name === path && l.formName === formName);
       if (listener) {
-        if (listener.type === "array") {
-          if (!isEqual(getFormItemValue(formName, p), get(values, p))) {
-            listener.onArrayChange(get(values, listener.name), options);
-            const nestedAllStringPath = getAllNoneObjStringPath(get(values, p));
-            nestedAllStringPath.forEach((np) => {
-              {
-                const findListener = getListeners().find((l) => l.name === `${p}.${np}` && l.formName === formName);
-                if (findListener) {
-                  findListener.onChange(get(values, `${p}.${np}`), options);
-                } else {
-                  setData(formName, `${p}.${np}`, get(values, `${p}.${np}`));
-                }
-              }
-            });
-          }
-        } else {
-          listener.onChange(get(values, listener.name), options);
-        }
+        listener.onChange(pathValue, options);
       } else {
-        setData(formName, p, get(values, p));
+        setData(formName, path, pathValue);
       }
     });
   };
-  const getFieldValue = (name) => {
+  function getFieldValue(name) {
     return getFormItemValue(formName, name);
-  };
+  }
   const getFieldValues = (names = []) => {
     return names.map((name) => ({
       name,
@@ -333,6 +439,17 @@ function useWatch(name, formNameOrFormInstance) {
   });
   return value;
 }
+function useWatchNormalized({ name, normalizeFn, formNameOrFormInstance }) {
+  const [formInstance] = useForm(formNameOrFormInstance);
+  const rawValue = useFormStore((state) => {
+    var _a;
+    return state.getFormItemValue((_a = formInstance == null ? void 0 : formInstance.formName) != null ? _a : formNameOrFormInstance, name);
+  });
+  const normalizedValue = useMemo(() => {
+    return normalizeFn(rawValue);
+  }, [rawValue, normalizeFn]);
+  return normalizedValue;
+}
 function useSubmitDataWatch({ formNameOrFormInstance, triggerWhenChange = false, mapFn }) {
   const [formInstance] = useForm(formNameOrFormInstance);
   const value = useFormStore((state) => {
@@ -368,6 +485,7 @@ const useFormItemStateWatch = (nameOrFormItemId, formNameOrFormInstance) => {
 Form.useForm = useForm;
 Form.Item = FormItem;
 Form.useWatch = useWatch;
+Form.useWatchNormalized = useWatchNormalized;
 Form.useSubmitDataWatch = useSubmitDataWatch;
 Form.useFormStateWatch = useFormStateWatch;
 Form.useFormItemStateWatch = useFormItemStateWatch;
@@ -379,5 +497,6 @@ export {
   useFormItemStateWatch,
   useFormStateWatch,
   useSubmitDataWatch,
-  useWatch
+  useWatch,
+  useWatchNormalized
 };

package/dist/test/TestWatchNormalize.d.ts

@@ -0,0 +1,3 @@
+type Props = {};
+declare function TestWatchNormalize({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestWatchNormalize;

package/dist/test/TestWatchNormalize.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Input } from "antd";
+import React from "react";
+import Form from "../providers/Form";
+function TestWatchNormalize({}) {
+  const normalizeData = Form.useWatchNormalized({
+    name: "normalizeItem",
+    formNameOrFormInstance: "testNormalize",
+    normalizeFn: (value) => {
+      if (typeof value === "string") {
+        return value.toUpperCase();
+      }
+      return value;
+    }
+  });
+  React.useEffect(() => {
+  }, [normalizeData]);
+  return _jsxs(Form, { formName: "testNormalize", children: ["Test Watch Normalize", _jsx(Form.Item, { name: "normalizeItem", children: _jsx(Input, {}) })] });
+}
+var stdin_default = TestWatchNormalize;
+export {
+  stdin_default as default
+};

package/dist/test/testSetValue/TestCase10_SetFieldValues_ComplexNested.d.ts

@@ -0,0 +1,21 @@
+type Props = {};
+/**
+ * Test Case 10: setFieldValues với Complex Nested Structure
+ *
+ * Cấu trúc phức tạp:
+ * - config.appName (string)
+ * - config.version (string)
+ * - config.features (array) - deepTrigger
+ * - users (FormList array) - deepTrigger
+ *   - users.0.name (string)
+ *   - users.0.roles (array) - nested array trong FormList
+ *
+ * Test: setFieldValues với structure phức tạp nhiều cấp
+ *
+ * Kỳ vọng:
+ * - Primitives trigger onChange
+ * - Arrays ở mọi level đều gọi handleDeepTriggerSet
+ * - Nested arrays trong FormList được xử lý đúng
+ */
+declare function TestCase10_SetFieldValues_ComplexNested({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestCase10_SetFieldValues_ComplexNested;

package/dist/test/testSetValue/TestCase10_SetFieldValues_ComplexNested.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { Button, Input, Typography } from "antd";
+import FormList from "../../components/Form/FormList";
+import Form from "../../providers/Form";
+function TestCase10_SetFieldValues_ComplexNested({}) {
+  const [form] = Form.useForm("testCase10");
+  const handleTestSetFieldValues = () => {
+    form == null ? void 0 : form.setFieldValues({
+      config: {
+        appName: "My App",
+        version: "1.0.0",
+        features: ["auth", "api", "ui"]
+      },
+      users: [
+        { name: "John", roles: ["admin", "editor"] },
+        { name: "Jane", roles: ["viewer"] }
+      ]
+    });
+  };
+  const handleTestUpdateStructure = () => {
+    form == null ? void 0 : form.setFieldValues({
+      config: {
+        appName: "Updated App",
+        version: "2.0.0",
+        features: ["auth", "api"]
+        // removed "ui"
+      },
+      users: [
+        { name: "John", roles: ["admin"] }
+        // removed editor role + removed Jane user
+      ]
+    });
+  };
+  const handleClear = () => {
+    form == null ? void 0 : form.setFieldValues({
+      config: {
+        appName: "",
+        version: "",
+        features: []
+      },
+      users: []
+    });
+  };
+  return _jsxs(Box, { sx: { p: 2 }, children: [_jsx(Typography.Title, { level: 4, children: "Test Case 10: setFieldValues - Complex Nested" }), _jsx(Typography.Paragraph, { children: "Test setFieldValues v\u1EDBi structure ph\u1EE9c t\u1EA1p: nested objects + arrays + FormList" }), _jsxs(Form, { formName: "testCase10", children: [_jsxs(Box, { sx: { border: "2px solid #1890ff", p: 2, mb: 2, borderRadius: 1 }, children: [_jsx(Typography.Text, { strong: true, style: { fontSize: 16 }, children: "Config" }), _jsx(Form.Item, { name: "config.appName", label: "App Name", children: _jsx(Input, { placeholder: "Enter app name" }) }), _jsx(Form.Item, { name: "config.version", label: "Version", children: _jsx(Input, { placeholder: "Enter version" }) }), _jsxs(Box, { sx: { mt: 1 }, children: [_jsx(Typography.Text, { children: "Features (Array):" }), _jsx(Form.Item, { name: "config.features.0", children: _jsx(Input, { placeholder: "Feature 1" }) }), _jsx(Form.Item, { name: "config.features.1", children: _jsx(Input, { placeholder: "Feature 2" }) }), _jsx(Form.Item, { name: "config.features.2", children: _jsx(Input, { placeholder: "Feature 3" }) })] })] }), _jsxs(Box, { sx: { border: "2px solid #52c41a", p: 2, mb: 2, borderRadius: 1 }, children: [_jsx(Typography.Text, { strong: true, style: { fontSize: 16 }, children: "Users (FormList)" }), _jsx(FormList, { name: "users", children: (fields, { add, remove }) => _jsxs(Box, { children: [fields.map((field, index) => _jsxs(Box, { sx: {
+    border: "1px dashed #52c41a",
+    p: 1,
+    mb: 1,
+    borderRadius: 1
+  }, children: [_jsxs(Typography.Text, { children: ["User ", index + 1] }), _jsx(Form.Item, { name: `users.${index}.name`, label: "Name", children: _jsx(Input, { placeholder: "User name" }) }), _jsxs(Box, { sx: { ml: 2, bgcolor: "#f6ffed", p: 1, borderRadius: 1 }, children: [_jsx(Typography.Text, { children: "Roles (Nested Array):" }), _jsx(Form.Item, { name: `users.${index}.roles.0`, children: _jsx(Input, { placeholder: "Role 1" }) }), _jsx(Form.Item, { name: `users.${index}.roles.1`, children: _jsx(Input, { placeholder: "Role 2" }) })] }), _jsx(Button, { danger: true, size: "small", onClick: () => remove({ key: field.key }), children: "Remove User" })] }, field.key)), _jsx(Button, { type: "dashed", onClick: () => add(), children: "Add User" })] }) })] }), _jsxs(Box, { sx: { mt: 2, display: "flex", gap: 2, flexDirection: "column" }, children: [_jsx(Button, { type: "primary", onClick: handleTestSetFieldValues, children: "1. Set Complex Structure" }), _jsx(Button, { onClick: handleTestUpdateStructure, children: "2. Update with Cleanup" }), _jsx(Button, { danger: true, onClick: handleClear, children: "3. Clear All" })] }), _jsxs(Box, { sx: {
+    mt: 2,
+    p: 2,
+    bgcolor: "#e6fffb",
+    border: "1px solid #13c2c2",
+    borderRadius: 1
+  }, children: [_jsx(Typography.Text, { strong: true, children: "Expected Behavior:" }), _jsxs(Typography.Paragraph, { children: [_jsx("strong", { children: "setFieldValues logic:" }), _jsx("br", {}), "- Traverse object, d\u1EEBng t\u1EA1i m\u1ED7i array", _jsx("br", {}), "- Primitives: trigger onChange", _jsx("br", {}), "- Arrays: g\u1ECDi handleDeepTriggerSet", _jsx("br", {}), _jsx("br", {}), _jsx("strong", { children: "Update with Cleanup:" }), _jsx("br", {}), "- config.features.2 \u2192 undefined (removed)", _jsx("br", {}), "- users.1 \u2192 undefined (Jane removed)", _jsx("br", {}), "- users.0.roles.1 \u2192 undefined (editor removed)"] })] })] })] });
+}
+var stdin_default = TestCase10_SetFieldValues_ComplexNested;
+export {
+  stdin_default as default
+};

package/dist/test/testSetValue/TestCase1_PlainObjectToPrimitives.d.ts

@@ -0,0 +1,16 @@
+type Props = {};
+/**
+ * Test Case 1: Plain Object → Primitive Listeners
+ *
+ * Cấu trúc:
+ * - user.name (string)
+ * - user.age (number)
+ *
+ * Test: setFieldValue("user", {name: "John", age: 30}, {deepTrigger: true})
+ * Kỳ vọng:
+ * - Trigger "user" listener (nếu có)
+ * - Trigger "user.name" listener
+ * - Trigger "user.age" listener
+ */
+declare function TestCase1_PlainObjectToPrimitives({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestCase1_PlainObjectToPrimitives;

package/dist/test/testSetValue/TestCase1_PlainObjectToPrimitives.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { Button, Input, Typography } from "antd";
+import Form from "../../providers/Form";
+function TestCase1_PlainObjectToPrimitives({}) {
+  const [form] = Form.useForm("testCase1");
+  const handleTestDeepTrigger = () => {
+    form == null ? void 0 : form.setFieldValue("user", { name: "John Doe", age: 30 }, { deepTrigger: true });
+  };
+  const handleTestNormalSet = () => {
+    form == null ? void 0 : form.setFieldValue("user", { name: "Jane Doe", age: 25 });
+  };
+  return _jsxs(Box, { sx: { p: 2 }, children: [_jsx(Typography.Title, { level: 4, children: "Test Case 1: Plain Object \u2192 Primitive Listeners" }), _jsxs(Typography.Paragraph, { children: ['Test setFieldValue("user", ', "{name, age}", ") v\u1EDBi deepTrigger=true"] }), _jsxs(Form, { formName: "testCase1", children: [_jsx(Form.Item, { name: "user", children: _jsx(Input, { placeholder: "User Object (JSON)", disabled: true }) }), _jsx(Form.Item, { name: "user.name", label: "Name", children: _jsx(Input, { placeholder: "Enter name" }) }), _jsx(Form.Item, { name: "user.age", label: "Age", children: _jsx(Input, { type: "number", placeholder: "Enter age" }) }), _jsxs(Box, { sx: { mt: 2, display: "flex", gap: 2 }, children: [_jsx(Button, { type: "primary", onClick: handleTestDeepTrigger, children: "Test Deep Trigger" }), _jsx(Button, { onClick: handleTestNormalSet, children: "Test Normal Set" })] })] })] });
+}
+var stdin_default = TestCase1_PlainObjectToPrimitives;
+export {
+  stdin_default as default
+};

package/dist/test/testSetValue/TestCase2_PlainObjectToFormList.d.ts

@@ -0,0 +1,21 @@
+type Props = {};
+/**
+ * Test Case 2: Plain Object → Array Listener (FormList) → Primitives
+ *
+ * Cấu trúc:
+ * - user.name (string)
+ * - user.items (array - FormList)
+ *   - user.items.0.id (number)
+ *   - user.items.0.title (string)
+ *
+ * Test: setFieldValue("user", {name: "John", items: [{id: 1, title: "Item 1"}]}, {deepTrigger: true})
+ * Kỳ vọng:
+ * - Trigger "user" listener
+ * - Trigger "user.name" listener
+ * - Trigger "user.items" onArrayChange
+ * - Trigger "user.items.0" listener
+ * - Trigger "user.items.0.id" listener
+ * - Trigger "user.items.0.title" listener
+ */
+declare function TestCase2_PlainObjectToFormList({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestCase2_PlainObjectToFormList;

package/dist/test/testSetValue/TestCase2_PlainObjectToFormList.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { Button, Input, Typography } from "antd";
+import FormList from "../../components/Form/FormList";
+import Form from "../../providers/Form";
+function TestCase2_PlainObjectToFormList({}) {
+  const [form] = Form.useForm("testCase2");
+  const handleTestDeepTrigger = () => {
+    form == null ? void 0 : form.setFieldValue("user", {
+      name: "John Doe",
+      items: [
+        { id: 1, title: "Item 1" },
+        { id: 2, title: "Item 2" }
+      ]
+    }, { deepTrigger: true });
+  };
+  const handleTestNormalSet = () => {
+    form == null ? void 0 : form.setFieldValue("user", {
+      name: "Jane Doe",
+      items: [{ id: 3, title: "Item 3" }]
+    });
+  };
+  return _jsxs(Box, { sx: { p: 2 }, children: [_jsx(Typography.Title, { level: 4, children: "Test Case 2: Plain Object \u2192 FormList \u2192 Primitives" }), _jsxs(Typography.Paragraph, { children: ['Test setFieldValue("user", ', "{name, items: [...]}", ") v\u1EDBi nested FormList"] }), _jsxs(Form, { formName: "testCase2", children: [_jsx(Form.Item, { name: "user.name", label: "User Name", children: _jsx(Input, { placeholder: "Enter user name" }) }), _jsx(FormList, { name: "user.items", children: (fields, { add, remove }) => _jsxs(Box, { children: [fields.map((field, index) => _jsxs(Box, { sx: {
+    border: "1px solid #d9d9d9",
+    p: 2,
+    mb: 2,
+    borderRadius: 1
+  }, children: [_jsxs(Typography.Text, { strong: true, children: ["Item ", index + 1] }), _jsx(Form.Item, { name: `user.items.${index}.id`, label: "ID", children: _jsx(Input, { placeholder: "Item ID" }) }), _jsx(Form.Item, { name: `user.items.${index}.title`, label: "Title", children: _jsx(Input, { placeholder: "Item title" }) }), _jsx(Button, { danger: true, onClick: () => remove({ key: field.key }), children: "Remove" })] }, field.key)), _jsx(Button, { type: "dashed", onClick: () => add(), children: "Add Item" })] }) }), _jsxs(Box, { sx: { mt: 2, display: "flex", gap: 2 }, children: [_jsx(Button, { type: "primary", onClick: handleTestDeepTrigger, children: "Test Deep Trigger" }), _jsx(Button, { onClick: handleTestNormalSet, children: "Test Normal Set" })] })] })] });
+}
+var stdin_default = TestCase2_PlainObjectToFormList;
+export {
+  stdin_default as default
+};

package/dist/test/testSetValue/TestCase3_ArrayNonListenerToPrimitives.d.ts

@@ -0,0 +1,21 @@
+type Props = {};
+/**
+ * Test Case 3: Array Non-Listener → Primitives
+ *
+ * Cấu trúc:
+ * - data (array - KHÔNG phải FormList, chỉ là field bình thường)
+ *   - data.0.name (string)
+ *   - data.0.value (number)
+ *
+ * Test: setFieldValue("data", [{name: "A", value: 1}, {name: "B", value: 2}], {deepTrigger: true})
+ * Kỳ vọng:
+ * - Set data array vào store
+ * - Trigger "data.0" listener (nếu có)
+ * - Trigger "data.0.name" listener
+ * - Trigger "data.0.value" listener
+ * - Trigger "data.1" listener (nếu có)
+ * - Trigger "data.1.name" listener
+ * - Trigger "data.1.value" listener
+ */
+declare function TestCase3_ArrayNonListenerToPrimitives({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestCase3_ArrayNonListenerToPrimitives;

package/dist/test/testSetValue/TestCase3_ArrayNonListenerToPrimitives.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { Button, Input, Typography } from "antd";
+import Form from "../../providers/Form";
+function TestCase3_ArrayNonListenerToPrimitives({}) {
+  const [form] = Form.useForm("testCase3");
+  const handleTestDeepTrigger = () => {
+    form == null ? void 0 : form.setFieldValue("data", [
+      { name: "Item A", value: 100 },
+      { name: "Item B", value: 200 }
+    ], { deepTrigger: true });
+  };
+  const handleTestRemoveItems = () => {
+    form == null ? void 0 : form.setFieldValue("data", [{ name: "Item A", value: 100 }], {
+      deepTrigger: true
+    });
+  };
+  const handleTestNormalSet = () => {
+    form == null ? void 0 : form.setFieldValue("data", [{ name: "Item C", value: 300 }]);
+  };
+  return _jsxs(Box, { sx: { p: 2 }, children: [_jsx(Typography.Title, { level: 4, children: "Test Case 3: Array Non-Listener \u2192 Primitives" }), _jsxs(Typography.Paragraph, { children: ['Test setFieldValue("data", ', "[{name, value}, ...]", ") v\u1EDBi array kh\xF4ng ph\u1EA3i FormList"] }), _jsxs(Form, { formName: "testCase3", children: [_jsxs(Box, { sx: { border: "1px solid #d9d9d9", p: 2, mb: 2, borderRadius: 1 }, children: [_jsx(Typography.Text, { strong: true, children: "Item 0" }), _jsx(Form.Item, { name: "data.0.name", label: "Name", children: _jsx(Input, { placeholder: "Item 0 name" }) }), _jsx(Form.Item, { name: "data.0.value", label: "Value", children: _jsx(Input, { type: "number", placeholder: "Item 0 value" }) })] }), _jsxs(Box, { sx: { border: "1px solid #d9d9d9", p: 2, mb: 2, borderRadius: 1 }, children: [_jsx(Typography.Text, { strong: true, children: "Item 1" }), _jsx(Form.Item, { name: "data.1.name", label: "Name", children: _jsx(Input, { placeholder: "Item 1 name" }) }), _jsx(Form.Item, { name: "data.1.value", label: "Value", children: _jsx(Input, { type: "number", placeholder: "Item 1 value" }) })] }), _jsxs(Box, { sx: { mt: 2, display: "flex", gap: 2 }, children: [_jsx(Button, { type: "primary", onClick: handleTestDeepTrigger, children: "Test Deep Trigger (2 items)" }), _jsx(Button, { onClick: handleTestRemoveItems, children: "Test Remove Items (1 item)" }), _jsx(Button, { onClick: handleTestNormalSet, children: "Test Normal Set" })] })] })] });
+}
+var stdin_default = TestCase3_ArrayNonListenerToPrimitives;
+export {
+  stdin_default as default
+};

package/dist/test/testSetValue/TestCase4_PlainObjectRemovedFields.d.ts

@@ -0,0 +1,20 @@
+type Props = {};
+/**
+ * Test Case 4: Plain Object with Removed Fields (Edge Case)
+ *
+ * Cấu trúc ban đầu:
+ * - profile.name (string)
+ * - profile.city (string)
+ * - profile.country (string)
+ *
+ * Test:
+ * 1. Set initial: {name: "John", city: "NY", country: "USA"}
+ * 2. Set removed: {name: "John"} (city và country bị xóa)
+ *
+ * Kỳ vọng:
+ * - Trigger "profile.name" với "John"
+ * - Trigger "profile.city" với undefined (cleanup)
+ * - Trigger "profile.country" với undefined (cleanup)
+ */
+declare function TestCase4_PlainObjectRemovedFields({}: Props): import("react/jsx-runtime").JSX.Element;
+export default TestCase4_PlainObjectRemovedFields;