@baseplate-dev/plugin-auth 4.0.3 → 5.0.1

package/dist/web/assets/{index.esm-1qBxxnfu.js → index.esm-BraHxHLB.js}

@@ -1,9 +1,7 @@
-import { importShared } from './__federation_fn_import-DfNliZHH.js';
+import { importShared } from './__federation_fn_import-BLFDCY-V.js';
 
 const React = await importShared('react');
 
-const React__default = await importShared('react');
-
 
 var isCheckBoxInput = (element) => element.type === 'checkbox';
 
@@ -37,29 +35,23 @@ var isWeb = typeof window !== 'undefined' &&
     typeof document !== 'undefined';
 
 function cloneObject(data) {
-    let copy;
-    const isArray = Array.isArray(data);
-    const isFileListInstance = typeof FileList !== 'undefined' ? data instanceof FileList : false;
     if (data instanceof Date) {
-        copy = new Date(data);
+        return new Date(data);
     }
-    else if (!(isWeb && (data instanceof Blob || isFileListInstance)) &&
-        (isArray || isObject(data))) {
-        copy = isArray ? [] : {};
-        if (!isArray && !isPlainObject(data)) {
-            copy = data;
-        }
-        else {
-            for (const key in data) {
-                if (data.hasOwnProperty(key)) {
-                    copy[key] = cloneObject(data[key]);
-                }
-            }
-        }
+    const isFileListInstance = typeof FileList !== 'undefined' && data instanceof FileList;
+    if (isWeb && (data instanceof Blob || isFileListInstance)) {
+        return data;
     }
-    else {
+    const isArray = Array.isArray(data);
+    if (!isArray && !(isObject(data) && isPlainObject(data))) {
         return data;
     }
+    const copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            copy[key] = cloneObject(data[key]);
+        }
+    }
     return copy;
 }
 
@@ -85,6 +77,8 @@ var get = (object, path, defaultValue) => {
 
 var isBoolean = (value) => typeof value === 'boolean';
 
+var isFunction = (value) => typeof value === 'function';
+
 var set = (object, path, value) => {
     let index = -1;
     const tempPath = isKey(path) ? [path] : stringToPath(path);
@@ -132,39 +126,16 @@ const INPUT_VALIDATION_RULES = {
     validate: 'validate',
 };
 
-const HookFormContext = React__default.createContext(null);
-HookFormContext.displayName = 'HookFormContext';
 /**
- * This custom hook allows you to access the form context. useFormContext is intended to be used in deeply nested structures, where it would become inconvenient to pass the context as a prop. To be used with {@link FormProvider}.
- *
- * @remarks
- * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
- *
- * @returns return all useForm methods
- *
- * @example
- * ```tsx
- * function App() {
- *   const methods = useForm();
- *   const onSubmit = data => console.log(data);
- *
- *   return (
- *     <FormProvider {...methods} >
- *       <form onSubmit={methods.handleSubmit(onSubmit)}>
- *         <NestedInput />
- *         <input type="submit" />
- *       </form>
- *     </FormProvider>
- *   );
- * }
- *
- *  function NestedInput() {
- *   const { register } = useFormContext(); // retrieve all hook methods
- *   return <input {...register("test")} />;
- * }
- * ```
+ * Separate context for `control` to prevent unnecessary rerenders.
+ * Internal hooks that only need control use this instead of full form context.
+ */
+const HookFormControlContext = React.createContext(null);
+HookFormControlContext.displayName = 'HookFormControlContext';
+/**
+ * @internal Internal hook to access only control from context.
  */
-const useFormContext = () => React__default.useContext(HookFormContext);
+const useFormControlContext = () => React.useContext(HookFormControlContext);
 
 var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
     const result = {
@@ -218,10 +189,10 @@ const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayou
  * ```
  */
 function useFormState(props) {
-    const methods = useFormContext();
-    const { control = methods.control, disabled, name, exact } = props || {};
-    const [formState, updateFormState] = React__default.useState(control._formState);
-    const _localProxyFormState = React__default.useRef({
+    const formControl = useFormControlContext();
+    const { control = formControl, disabled, name, exact } = props || {};
+    const [formState, updateFormState] = React.useState(control._formState);
+    const _localProxyFormState = React.useRef({
         isDirty: false,
         isLoading: false,
         dirtyFields: false,
@@ -243,10 +214,10 @@ function useFormState(props) {
                 });
         },
     }), [name, disabled, exact]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         _localProxyFormState.current.isValid && control._setValid(true);
     }, [control]);
-    return React__default.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
+    return React.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
 }
 
 var isString = (value) => typeof value === 'string';
@@ -264,6 +235,44 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
     return formValues;
 };
 
+var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
+
+function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
+    if (isPrimitive(object1) || isPrimitive(object2)) {
+        return Object.is(object1, object2);
+    }
+    if (isDateObject(object1) && isDateObject(object2)) {
+        return Object.is(object1.getTime(), object2.getTime());
+    }
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    if (_internal_visited.has(object1) || _internal_visited.has(object2)) {
+        return true;
+    }
+    _internal_visited.add(object1);
+    _internal_visited.add(object2);
+    for (const key of keys1) {
+        const val1 = object1[key];
+        if (!keys2.includes(key)) {
+            return false;
+        }
+        if (key !== 'ref') {
+            const val2 = object2[key];
+            if ((isDateObject(val1) && isDateObject(val2)) ||
+                (isObject(val1) && isObject(val2)) ||
+                (Array.isArray(val1) && Array.isArray(val2))
+                ? !deepEqual(val1, val2, _internal_visited)
+                : !Object.is(val1, val2)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 /**
  * Custom hook to subscribe to field change and isolate re-rendering at the component level.
  *
@@ -281,21 +290,73 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
  * ```
  */
 function useWatch(props) {
-    const methods = useFormContext();
-    const { control = methods.control, name, defaultValue, disabled, exact, } = props || {};
-    const _defaultValue = React__default.useRef(defaultValue);
-    const [value, updateValue] = React__default.useState(control._getWatch(name, _defaultValue.current));
-    useIsomorphicLayoutEffect(() => control._subscribe({
-        name,
-        formState: {
-            values: true,
-        },
-        exact,
-        callback: (formState) => !disabled &&
-            updateValue(generateWatchOutput(name, control._names, formState.values || control._formValues, false, _defaultValue.current)),
-    }), [name, control, disabled, exact]);
-    React__default.useEffect(() => control._removeUnmounted());
-    return value;
+    const formControl = useFormControlContext();
+    const { control = formControl, name, defaultValue, disabled, exact, compute, } = props || {};
+    const _defaultValue = React.useRef(defaultValue);
+    const _compute = React.useRef(compute);
+    const _computeFormValues = React.useRef(undefined);
+    const _prevControl = React.useRef(control);
+    const _prevName = React.useRef(name);
+    _compute.current = compute;
+    const [value, updateValue] = React.useState(() => {
+        const defaultValue = control._getWatch(name, _defaultValue.current);
+        return _compute.current ? _compute.current(defaultValue) : defaultValue;
+    });
+    const getCurrentOutput = React.useCallback((values) => {
+        const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+        return _compute.current ? _compute.current(formValues) : formValues;
+    }, [control._formValues, control._names, name]);
+    const refreshValue = React.useCallback((values) => {
+        if (!disabled) {
+            const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+            if (_compute.current) {
+                const computedFormValues = _compute.current(formValues);
+                if (!deepEqual(computedFormValues, _computeFormValues.current)) {
+                    updateValue(computedFormValues);
+                    _computeFormValues.current = computedFormValues;
+                }
+            }
+            else {
+                updateValue(formValues);
+            }
+        }
+    }, [control._formValues, control._names, disabled, name]);
+    useIsomorphicLayoutEffect(() => {
+        if (_prevControl.current !== control ||
+            !deepEqual(_prevName.current, name)) {
+            _prevControl.current = control;
+            _prevName.current = name;
+            refreshValue();
+        }
+        return control._subscribe({
+            name,
+            formState: {
+                values: true,
+            },
+            exact,
+            callback: (formState) => {
+                refreshValue(formState.values);
+            },
+        });
+    }, [control, exact, name, refreshValue]);
+    React.useEffect(() => control._removeUnmounted());
+    // If name or control changed for this render, synchronously reflect the
+    // latest value so callers (like useController) see the correct value
+    // immediately on the same render.
+    // Optimize: Check control reference first before expensive deepEqual
+    const controlChanged = _prevControl.current !== control;
+    const prevName = _prevName.current;
+    // Cache the computed output to avoid duplicate calls within the same render
+    // We include shouldReturnImmediate in deps to ensure proper recomputation
+    const computedOutput = React.useMemo(() => {
+        if (disabled) {
+            return null;
+        }
+        const nameChanged = !controlChanged && !deepEqual(prevName, name);
+        const shouldReturnImmediate = controlChanged || nameChanged;
+        return shouldReturnImmediate ? getCurrentOutput() : null;
+    }, [disabled, controlChanged, name, prevName, getCurrentOutput]);
+    return computedOutput !== null ? computedOutput : value;
 }
 
 /**
@@ -323,27 +384,30 @@ function useWatch(props) {
  * ```
  */
 function useController(props) {
-    const methods = useFormContext();
-    const { name, disabled, control = methods.control, shouldUnregister } = props;
+    const formControl = useFormControlContext();
+    const { name, disabled, control = formControl, shouldUnregister, defaultValue, exact = true, } = props;
     const isArrayField = isNameInFieldArray(control._names.array, name);
+    const defaultValueMemo = React.useMemo(() => get(control._formValues, name, get(control._defaultValues, name, defaultValue)), [control, name, defaultValue]);
     const value = useWatch({
         control,
         name,
-        defaultValue: get(control._formValues, name, get(control._defaultValues, name, props.defaultValue)),
-        exact: true,
+        defaultValue: defaultValueMemo,
+        exact,
     });
     const formState = useFormState({
         control,
         name,
-        exact: true,
+        exact,
     });
-    const _props = React__default.useRef(props);
-    const _registerProps = React__default.useRef(control.register(name, {
+    const _props = React.useRef(props);
+    const _previousNameRef = React.useRef(undefined);
+    const _registerProps = React.useRef(control.register(name, {
         ...props.rules,
         value,
         ...(isBoolean(props.disabled) ? { disabled: props.disabled } : {}),
     }));
-    const fieldState = React__default.useMemo(() => Object.defineProperties({}, {
+    _props.current = props;
+    const fieldState = React.useMemo(() => Object.defineProperties({}, {
         invalid: {
             enumerable: true,
             get: () => !!get(formState.errors, name),
@@ -365,32 +429,32 @@ function useController(props) {
             get: () => get(formState.errors, name),
         },
     }), [formState, name]);
-    const onChange = React__default.useCallback((event) => _registerProps.current.onChange({
+    const onChange = React.useCallback((event) => _registerProps.current.onChange({
         target: {
             value: getEventValue(event),
             name: name,
         },
         type: EVENTS.CHANGE,
     }), [name]);
-    const onBlur = React__default.useCallback(() => _registerProps.current.onBlur({
+    const onBlur = React.useCallback(() => _registerProps.current.onBlur({
         target: {
             value: get(control._formValues, name),
             name: name,
         },
         type: EVENTS.BLUR,
     }), [name, control._formValues]);
-    const ref = React__default.useCallback((elm) => {
+    const ref = React.useCallback((elm) => {
         const field = get(control._fields, name);
-        if (field && elm) {
+        if (field && field._f && elm) {
             field._f.ref = {
-                focus: () => elm.focus && elm.focus(),
-                select: () => elm.select && elm.select(),
-                setCustomValidity: (message) => elm.setCustomValidity(message),
-                reportValidity: () => elm.reportValidity(),
+                focus: () => isFunction(elm.focus) && elm.focus(),
+                select: () => isFunction(elm.select) && elm.select(),
+                setCustomValidity: (message) => isFunction(elm.setCustomValidity) && elm.setCustomValidity(message),
+                reportValidity: () => isFunction(elm.reportValidity) && elm.reportValidity(),
             };
         }
     }, [control._fields, name]);
-    const field = React__default.useMemo(() => ({
+    const field = React.useMemo(() => ({
         name,
         value,
         ...(isBoolean(disabled) || formState.disabled
@@ -400,8 +464,12 @@ function useController(props) {
         onBlur,
         ref,
     }), [name, disabled, formState.disabled, onChange, onBlur, ref, value]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
+        const previousName = _previousNameRef.current;
+        if (previousName && previousName !== name && !isArrayField) {
+            control.unregister(previousName);
+        }
         control.register(name, {
             ..._props.current.rules,
             ...(isBoolean(_props.current.disabled)
@@ -416,13 +484,14 @@ function useController(props) {
         };
         updateMounted(name, true);
         if (_shouldUnregisterField) {
-            const value = cloneObject(get(control._options.defaultValues, name));
+            const value = cloneObject(get(control._options.defaultValues, name, _props.current.defaultValue));
             set(control._defaultValues, name, value);
             if (isUndefined(get(control._formValues, name))) {
                 set(control._formValues, name, value);
             }
         }
         !isArrayField && control.register(name);
+        _previousNameRef.current = name;
         return () => {
             (isArrayField
                 ? _shouldUnregisterField && !control._state.action
@@ -431,19 +500,22 @@ function useController(props) {
                 : updateMounted(name, false);
         };
     }, [name, control, isArrayField, shouldUnregister]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         control._setDisabledField({
             disabled,
             name,
         });
     }, [disabled, name, control]);
-    return React__default.useMemo(() => ({
+    return React.useMemo(() => ({
         field,
         formState,
         fieldState,
     }), [field, formState, fieldState]);
 }
 
+const HookFormContext = React.createContext(null);
+HookFormContext.displayName = 'HookFormContext';
+
 var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria
     ? {
         ...errors[name],
@@ -484,50 +556,30 @@ var createSubject = () => {
     };
 };
 
-var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
-
-function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
-    if (isPrimitive(object1) || isPrimitive(object2)) {
-        return object1 === object2;
-    }
-    if (isDateObject(object1) && isDateObject(object2)) {
-        return object1.getTime() === object2.getTime();
-    }
-    const keys1 = Object.keys(object1);
-    const keys2 = Object.keys(object2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-    if (_internal_visited.has(object1) || _internal_visited.has(object2)) {
-        return true;
-    }
-    _internal_visited.add(object1);
-    _internal_visited.add(object2);
-    for (const key of keys1) {
-        const val1 = object1[key];
-        if (!keys2.includes(key)) {
-            return false;
-        }
-        if (key !== 'ref') {
-            const val2 = object2[key];
-            if ((isDateObject(val1) && isDateObject(val2)) ||
-                (isObject(val1) && isObject(val2)) ||
-                (Array.isArray(val1) && Array.isArray(val2))
-                ? !deepEqual(val1, val2, _internal_visited)
-                : val1 !== val2) {
-                return false;
+function extractFormValues(fieldsState, formValues) {
+    const values = {};
+    for (const key in fieldsState) {
+        if (fieldsState.hasOwnProperty(key)) {
+            const fieldState = fieldsState[key];
+            const fieldValue = formValues[key];
+            if (fieldState && isObject(fieldState) && fieldValue) {
+                const nestedFieldsState = extractFormValues(fieldState, fieldValue);
+                if (isObject(nestedFieldsState)) {
+                    values[key] = nestedFieldsState;
+                }
+            }
+            else if (fieldsState[key]) {
+                values[key] = fieldValue;
             }
         }
     }
-    return true;
+    return values;
 }
 
 var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
 
 var isFileInput = (element) => element.type === 'file';
 
-var isFunction = (value) => typeof value === 'function';
-
 var isHTMLElement = (value) => {
     if (!isWeb) {
         return false;
@@ -590,46 +642,43 @@ var objectHasFunction = (data) => {
     return false;
 };
 
+function isTraversable(value) {
+    return Array.isArray(value) || (isObject(value) && !objectHasFunction(value));
+}
 function markFieldsDirty(data, fields = {}) {
-    const isParentNodeArray = Array.isArray(data);
-    if (isObject(data) || isParentNodeArray) {
-        for (const key in data) {
-            if (Array.isArray(data[key]) ||
-                (isObject(data[key]) && !objectHasFunction(data[key]))) {
-                fields[key] = Array.isArray(data[key]) ? [] : {};
-                markFieldsDirty(data[key], fields[key]);
-            }
-            else if (!isNullOrUndefined(data[key])) {
-                fields[key] = true;
-            }
+    for (const key in data) {
+        const value = data[key];
+        if (isTraversable(value)) {
+            fields[key] = Array.isArray(value) ? [] : {};
+            markFieldsDirty(value, fields[key]);
+        }
+        else if (!isUndefined(value)) {
+            fields[key] = true;
         }
     }
     return fields;
 }
-function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
-    const isParentNodeArray = Array.isArray(data);
-    if (isObject(data) || isParentNodeArray) {
-        for (const key in data) {
-            if (Array.isArray(data[key]) ||
-                (isObject(data[key]) && !objectHasFunction(data[key]))) {
-                if (isUndefined(formValues) ||
-                    isPrimitive(dirtyFieldsFromValues[key])) {
-                    dirtyFieldsFromValues[key] = Array.isArray(data[key])
-                        ? markFieldsDirty(data[key], [])
-                        : { ...markFieldsDirty(data[key]) };
-                }
-                else {
-                    getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
-                }
+function getDirtyFields(data, formValues, dirtyFieldsFromValues) {
+    if (!dirtyFieldsFromValues) {
+        dirtyFieldsFromValues = markFieldsDirty(formValues);
+    }
+    for (const key in data) {
+        const value = data[key];
+        if (isTraversable(value)) {
+            if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
+                dirtyFieldsFromValues[key] = markFieldsDirty(value, Array.isArray(value) ? [] : {});
             }
             else {
-                dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+                getDirtyFields(value, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
             }
         }
+        else {
+            const formValue = formValues[key];
+            dirtyFieldsFromValues[key] = !deepEqual(value, formValue);
+        }
     }
     return dirtyFieldsFromValues;
 }
-var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
 
 const defaultResult = {
     value: false,
@@ -863,15 +912,13 @@ var updateFieldArrayRootError = (errors, error, name) => {
     return errors;
 };
 
-var isMessage = (value) => isString(value);
-
 function getValidateError(result, ref, type = 'validate') {
-    if (isMessage(result) ||
-        (Array.isArray(result) && result.every(isMessage)) ||
+    if (isString(result) ||
+        (Array.isArray(result) && result.every(isString)) ||
         (isBoolean(result) && !result)) {
         return {
             type,
-            message: isMessage(result) ? result : '',
+            message: isString(result) ? result : '',
             ref,
         };
     }
@@ -924,7 +971,7 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
                 (isBoolean(inputValue) && !inputValue) ||
                 (isCheckBox && !getCheckboxValue(refs).isValid) ||
                 (isRadio && !getRadioValue(refs).isValid))) {
-        const { value, message } = isMessage(required)
+        const { value, message } = isString(required)
             ? { value: !!required, message: required }
             : getValueAndMessage(required);
         if (value) {
@@ -1100,6 +1147,7 @@ function createFormControl(props = {}) {
         action: false,
         mount: false,
         watch: false,
+        keepIsValid: false,
     };
     let _names = {
         mount: new Set(),
@@ -1110,7 +1158,7 @@ function createFormControl(props = {}) {
     };
     let delayErrorCallback;
     let timer = 0;
-    const _proxyFormState = {
+    const defaultProxyFormState = {
         isDirty: false,
         dirtyFields: false,
         validatingFields: false,
@@ -1119,6 +1167,9 @@ function createFormControl(props = {}) {
         isValid: false,
         errors: false,
     };
+    const _proxyFormState = {
+        ...defaultProxyFormState,
+    };
     let _proxySubscribeFormState = {
         ..._proxyFormState,
     };
@@ -1132,13 +1183,21 @@ function createFormControl(props = {}) {
         timer = setTimeout(callback, wait);
     };
     const _setValid = async (shouldUpdateValid) => {
+        if (_state.keepIsValid) {
+            return;
+        }
         if (!_options.disabled &&
             (_proxyFormState.isValid ||
                 _proxySubscribeFormState.isValid ||
                 shouldUpdateValid)) {
-            const isValid = _options.resolver
-                ? isEmptyObject((await _runSchema()).errors)
-                : await executeBuiltInValidation(_fields, true);
+            let isValid;
+            if (_options.resolver) {
+                isValid = isEmptyObject((await _runSchema()).errors);
+                _updateIsValidating();
+            }
+            else {
+                isValid = await executeBuiltInValidation(_fields, true);
+            }
             if (isValid !== _formState.isValid) {
                 _subjects.state.next({
                     isValid,
@@ -1222,7 +1281,7 @@ function createFormControl(props = {}) {
                 shouldSkipSetValueAs
                 ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
                 : setFieldValue(name, defaultValue);
-            _state.mount && _setValid();
+            _state.mount && !_state.action && _setValid();
         }
     };
     const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
@@ -1301,11 +1360,11 @@ function createFormControl(props = {}) {
     const _runSchema = async (name) => {
         _updateIsValidating(name, true);
         const result = await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
-        _updateIsValidating(name);
         return result;
     };
     const executeSchemaAndUpdateState = async (names) => {
         const { errors } = await _runSchema(names);
+        _updateIsValidating(names);
         if (names) {
             for (const name of names) {
                 const error = get(errors, name);
@@ -1330,15 +1389,15 @@ function createFormControl(props = {}) {
                     const isFieldArrayRoot = _names.array.has(_f.name);
                     const isPromiseFunction = field._f && hasPromiseValidation(field._f);
                     if (isPromiseFunction && _proxyFormState.validatingFields) {
-                        _updateIsValidating([name], true);
+                        _updateIsValidating([_f.name], true);
                     }
                     const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
                     if (isPromiseFunction && _proxyFormState.validatingFields) {
-                        _updateIsValidating([name]);
+                        _updateIsValidating([_f.name]);
                     }
                     if (fieldError[_f.name]) {
                         context.valid = false;
-                        if (shouldOnlyCheckValid) {
+                        if (shouldOnlyCheckValid || props.shouldUseNativeValidation) {
                             break;
                         }
                     }
@@ -1473,11 +1532,19 @@ function createFormControl(props = {}) {
                 ? setValues(name, cloneValue, options)
                 : setFieldValue(name, cloneValue, options);
         }
-        isWatched(name, _names) && _subjects.state.next({ ..._formState });
-        _subjects.state.next({
-            name: _state.mount ? name : undefined,
-            values: cloneObject(_formValues),
-        });
+        if (isWatched(name, _names)) {
+            _subjects.state.next({
+                ..._formState,
+                name,
+                values: cloneObject(_formValues),
+            });
+        }
+        else {
+            _subjects.state.next({
+                name: _state.mount ? name : undefined,
+                values: cloneObject(_formValues),
+            });
+        }
     };
     const onChange = async (event) => {
         _state.mount = true;
@@ -1508,8 +1575,10 @@ function createFormControl(props = {}) {
             const watched = isWatched(name, _names, isBlurEvent);
             set(_formValues, name, fieldValue);
             if (isBlurEvent) {
-                field._f.onBlur && field._f.onBlur(event);
-                delayErrorCallback && delayErrorCallback(0);
+                if (!target || !target.readOnly) {
+                    field._f.onBlur && field._f.onBlur(event);
+                    delayErrorCallback && delayErrorCallback(0);
+                }
             }
             else if (field._f.onChange) {
                 field._f.onChange(event);
@@ -1539,6 +1608,7 @@ function createFormControl(props = {}) {
             !isBlurEvent && watched && _subjects.state.next({ ..._formState });
             if (_options.resolver) {
                 const { errors } = await _runSchema([name]);
+                _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
                     const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
@@ -1565,6 +1635,7 @@ function createFormControl(props = {}) {
             }
             if (isFieldValueUpdated) {
                 field._f.deps &&
+                    (!Array.isArray(field._f.deps) || field._f.deps.length > 0) &&
                     trigger(field._f.deps);
                 shouldRenderByError(name, isValid, error, fieldState);
             }
@@ -1612,10 +1683,13 @@ function createFormControl(props = {}) {
             iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
         return validationResult;
     };
-    const getValues = (fieldNames) => {
-        const values = {
+    const getValues = (fieldNames, config) => {
+        let values = {
             ...(_state.mount ? _formValues : _defaultValues),
         };
+        if (config) {
+            values = extractFormValues(config.dirtyFields ? _formState.dirtyFields : _formState.touchedFields, values);
+        }
         return isUndefined(fieldNames)
             ? values
             : isString(fieldNames)
@@ -1655,7 +1729,8 @@ function createFormControl(props = {}) {
     };
     const watch = (name, defaultValue) => isFunction(name)
         ? _subjects.state.subscribe({
-            next: (payload) => name(_getWatch(undefined, defaultValue), payload),
+            next: (payload) => 'values' in payload &&
+                name(_getWatch(undefined, defaultValue), payload),
         })
         : _getWatch(name, defaultValue, true);
     const _subscribe = (props) => _subjects.state.subscribe({
@@ -1666,6 +1741,7 @@ function createFormControl(props = {}) {
                     values: { ..._formValues },
                     ..._formState,
                     ...formState,
+                    defaultValues: _defaultValues,
                 });
             }
         },
@@ -1678,7 +1754,10 @@ function createFormControl(props = {}) {
         };
         return _subscribe({
             ...props,
-            formState: _proxySubscribeFormState,
+            formState: {
+                ...defaultProxyFormState,
+                ...props.formState,
+            },
         });
     };
     const unregister = (name, options = {}) => {
@@ -1711,7 +1790,11 @@ function createFormControl(props = {}) {
         if ((isBoolean(disabled) && _state.mount) ||
             !!disabled ||
             _names.disabled.has(name)) {
+            const wasDisabled = _names.disabled.has(name);
+            const isDisabled = !!disabled;
+            const disabledStateChanged = wasDisabled !== isDisabled;
             disabled ? _names.disabled.add(name) : _names.disabled.delete(name);
+            disabledStateChanged && _state.mount && !_state.action && _setValid();
         }
     };
     const register = (name, options = {}) => {
@@ -1831,6 +1914,7 @@ function createFormControl(props = {}) {
         });
         if (_options.resolver) {
             const { errors, values } = await _runSchema();
+            _updateIsValidating();
             _formState.errors = errors;
             fieldValues = cloneObject(values);
         }
@@ -1912,9 +1996,15 @@ function createFormControl(props = {}) {
                     ...Object.keys(getDirtyFields(_defaultValues, _formValues)),
                 ]);
                 for (const fieldName of Array.from(fieldsToCheck)) {
-                    get(_formState.dirtyFields, fieldName)
-                        ? set(values, fieldName, get(_formValues, fieldName))
-                        : setValue(fieldName, get(values, fieldName));
+                    const isDirty = get(_formState.dirtyFields, fieldName);
+                    const existingValue = get(_formValues, fieldName);
+                    const newValue = get(values, fieldName);
+                    if (isDirty && !isUndefined(existingValue)) {
+                        set(values, fieldName, existingValue);
+                    }
+                    else if (!isDirty && !isUndefined(newValue)) {
+                        setValue(fieldName, newValue);
+                    }
                 }
             }
             else {
@@ -1968,8 +2058,17 @@ function createFormControl(props = {}) {
         _state.mount =
             !_proxyFormState.isValid ||
                 !!keepStateOptions.keepIsValid ||
-                !!keepStateOptions.keepDirtyValues;
+                !!keepStateOptions.keepDirtyValues ||
+                (!_options.shouldUnregister && !isEmptyObject(values));
         _state.watch = !!_options.shouldUnregister;
+        _state.keepIsValid = !!keepStateOptions.keepIsValid;
+        _state.action = false;
+        // Clear errors synchronously to prevent validation errors on subsequent submissions
+        // This fixes the issue where form.reset() causes validation errors on subsequent
+        // submissions in Next.js 16 with Server Actions
+        if (!keepStateOptions.keepErrors) {
+            _formState.errors = {};
+        }
         _subjects.state.next({
             submitCount: keepStateOptions.keepSubmitCount
                 ? _formState.submitCount
@@ -2002,11 +2101,12 @@ function createFormControl(props = {}) {
                 ? _formState.isSubmitSuccessful
                 : false,
             isSubmitting: false,
+            defaultValues: _defaultValues,
         });
     };
     const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues)
         ? formValues(_formValues)
-        : formValues, keepStateOptions);
+        : formValues, { ..._options.resetOptions, ...keepStateOptions });
     const setFocus = (name, options = {}) => {
         const field = get(_fields, name);
         const fieldReference = field && field._f;
@@ -2015,10 +2115,14 @@ function createFormControl(props = {}) {
                 ? fieldReference.refs[0]
                 : fieldReference.ref;
             if (fieldRef.focus) {
-                fieldRef.focus();
-                options.shouldSelect &&
-                    isFunction(fieldRef.select) &&
-                    fieldRef.select();
+                // Use setTimeout to ensure focus happens after any pending state updates
+                // This fixes the issue where setFocus doesn't work immediately after setError
+                setTimeout(() => {
+                    fieldRef.focus();
+                    options.shouldSelect &&
+                        isFunction(fieldRef.select) &&
+                        fieldRef.select();
+                });
             }
         }
     };
@@ -2044,6 +2148,7 @@ function createFormControl(props = {}) {
             setError,
             _subscribe,
             _runSchema,
+            _updateIsValidating,
             _focusError,
             _getWatch,
             _getDirty,
@@ -2119,7 +2224,7 @@ var generateId = () => {
     }
     const d = typeof performance === 'undefined' ? Date.now() : performance.now() * 1000;
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16 + d) % 16 | 0;
+        const r = ((Math.random() * 16 + d) % 16) | 0;
         return (c == 'x' ? r : (r & 0x3) | 0x8).toString(16);
     });
 };
@@ -2220,30 +2325,27 @@ var updateAt = (fieldValues, index, value) => {
  * ```
  */
 function useFieldArray(props) {
-    const methods = useFormContext();
-    const { control = methods.control, name, keyName = 'id', shouldUnregister, rules, } = props;
-    const [fields, setFields] = React__default.useState(control._getFieldArray(name));
-    const ids = React__default.useRef(control._getFieldArray(name).map(generateId));
-    const _fieldIds = React__default.useRef(fields);
-    const _name = React__default.useRef(name);
-    const _actioned = React__default.useRef(false);
-    _name.current = name;
-    _fieldIds.current = fields;
+    const formControl = useFormControlContext();
+    const { control = formControl, name, keyName = 'id', shouldUnregister, rules, } = props;
+    const [fields, setFields] = React.useState(control._getFieldArray(name));
+    const ids = React.useRef(control._getFieldArray(name).map(generateId));
+    const _actioned = React.useRef(false);
     control._names.array.add(name);
-    rules &&
-        control.register(name, rules);
+    React.useMemo(() => rules &&
+        fields.length >= 0 &&
+        control.register(name, rules), [control, name, fields.length, rules]);
     useIsomorphicLayoutEffect(() => control._subjects.array.subscribe({
         next: ({ values, name: fieldArrayName, }) => {
-            if (fieldArrayName === _name.current || !fieldArrayName) {
-                const fieldValues = get(values, _name.current);
+            if (fieldArrayName === name || !fieldArrayName) {
+                const fieldValues = get(values, name);
                 if (Array.isArray(fieldValues)) {
                     setFields(fieldValues);
                     ids.current = fieldValues.map(generateId);
                 }
             }
         },
-    }).unsubscribe, [control]);
-    const updateValues = React__default.useCallback((updatedFieldArrayValues) => {
+    }).unsubscribe, [control, name]);
+    const updateValues = React.useCallback((updatedFieldArrayValues) => {
         _actioned.current = true;
         control._setFieldArray(name, updatedFieldArrayValues);
     }, [control, name]);
@@ -2332,7 +2434,7 @@ function useFieldArray(props) {
         setFields([...updatedFieldArrayValues]);
         control._setFieldArray(name, [...updatedFieldArrayValues], (data) => data, {}, true, false);
     };
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         control._state.action = false;
         isWatched(name, control._names) &&
             control._subjects.state.next({
@@ -2344,6 +2446,7 @@ function useFieldArray(props) {
             !getValidationModes(control._options.reValidateMode).isOnSubmit) {
             if (control._options.resolver) {
                 control._runSchema([name]).then((result) => {
+                    control._updateIsValidating([name]);
                     const error = get(result.errors, name);
                     const existingError = get(control._formState.errors, name);
                     if (existingError
@@ -2392,7 +2495,7 @@ function useFieldArray(props) {
         control._setValid();
         _actioned.current = false;
     }, [fields, name, control]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         !get(control._formValues, name) && control._setFieldArray(name);
         return () => {
             const updateMounted = (name, value) => {
@@ -2407,15 +2510,15 @@ function useFieldArray(props) {
         };
     }, [name, control, keyName, shouldUnregister]);
     return {
-        swap: React__default.useCallback(swap, [updateValues, name, control]),
-        move: React__default.useCallback(move, [updateValues, name, control]),
-        prepend: React__default.useCallback(prepend, [updateValues, name, control]),
-        append: React__default.useCallback(append, [updateValues, name, control]),
-        remove: React__default.useCallback(remove, [updateValues, name, control]),
-        insert: React__default.useCallback(insert$1, [updateValues, name, control]),
-        update: React__default.useCallback(update, [updateValues, name, control]),
-        replace: React__default.useCallback(replace, [updateValues, name, control]),
-        fields: React__default.useMemo(() => fields.map((field, index) => ({
+        swap: React.useCallback(swap, [updateValues, name, control]),
+        move: React.useCallback(move, [updateValues, name, control]),
+        prepend: React.useCallback(prepend, [updateValues, name, control]),
+        append: React.useCallback(append, [updateValues, name, control]),
+        remove: React.useCallback(remove, [updateValues, name, control]),
+        insert: React.useCallback(insert$1, [updateValues, name, control]),
+        update: React.useCallback(update, [updateValues, name, control]),
+        replace: React.useCallback(replace, [updateValues, name, control]),
+        fields: React.useMemo(() => fields.map((field, index) => ({
             ...field,
             [keyName]: ids.current[index] || generateId(),
         })), [fields, keyName]),
@@ -2452,9 +2555,9 @@ function useFieldArray(props) {
  * ```
  */
 function useForm(props = {}) {
-    const _formControl = React__default.useRef(undefined);
-    const _values = React__default.useRef(undefined);
-    const [formState, updateFormState] = React__default.useState({
+    const _formControl = React.useRef(undefined);
+    const _values = React.useRef(undefined);
+    const [formState, updateFormState] = React.useState({
         isDirty: false,
         isValidating: false,
         isLoading: isFunction(props.defaultValues),
@@ -2506,8 +2609,8 @@ function useForm(props = {}) {
         control._formState.isReady = true;
         return sub;
     }, [control]);
-    React__default.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
-    React__default.useEffect(() => {
+    React.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
+    React.useEffect(() => {
         if (props.mode) {
             control._options.mode = props.mode;
         }
@@ -2515,19 +2618,19 @@ function useForm(props = {}) {
             control._options.reValidateMode = props.reValidateMode;
         }
     }, [control, props.mode, props.reValidateMode]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         if (props.errors) {
             control._setErrors(props.errors);
             control._focusError();
         }
     }, [control, props.errors]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         props.shouldUnregister &&
             control._subjects.state.next({
                 values: control._getWatch(),
             });
     }, [control, props.shouldUnregister]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         if (control._proxyFormState.isDirty) {
             const isDirty = control._getDirty();
             if (isDirty !== formState.isDirty) {
@@ -2537,12 +2640,16 @@ function useForm(props = {}) {
             }
         }
     }, [control, formState.isDirty]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
+        var _a;
         if (props.values && !deepEqual(props.values, _values.current)) {
             control._reset(props.values, {
                 keepFieldsRef: true,
                 ...control._options.resetOptions,
             });
+            if (!((_a = control._options.resetOptions) === null || _a === void 0 ? void 0 : _a.keepIsValid)) {
+                control._setValid();
+            }
             _values.current = props.values;
             updateFormState((state) => ({ ...state }));
         }
@@ -2550,7 +2657,7 @@ function useForm(props = {}) {
             control._resetDefaultValues();
         }
     }, [control, props.values]);
-    React__default.useEffect(() => {
+    React.useEffect(() => {
         if (!control._state.mount) {
             control._setValid();
             control._state.mount = true;
@@ -2561,9 +2668,9 @@ function useForm(props = {}) {
         }
         control._removeUnmounted();
     });
-    _formControl.current.formState = getProxyFormState(formState, control);
+    _formControl.current.formState = React.useMemo(() => getProxyFormState(formState, control), [control, formState]);
     return _formControl.current;
 }
 
 export { useForm as a, useController as b, useFieldArray as c, useWatch as d, appendErrors as e, get as g, set as s, useFormState as u };
-//# sourceMappingURL=index.esm-1qBxxnfu.js.map
+//# sourceMappingURL=index.esm-BraHxHLB.js.map