@vuehookform/core 0.4.0 → 0.4.2

package/dist/vuehookform.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let vue = require("vue");
 var pathCache = /* @__PURE__ */ new Map();
 var PATH_CACHE_MAX_SIZE = 256;
+var MAX_ARRAY_INDEX = 1e4;
 function getPathSegments(path) {
 	let segments = pathCache.get(path);
 	if (segments) return segments;
@@ -13,6 +14,9 @@ function getPathSegments(path) {
 	pathCache.set(path, segments);
 	return segments;
 }
+function clearPathCache() {
+	pathCache.clear();
+}
 function get(obj, path) {
 	if (!path || obj === null || obj === void 0) return obj;
 	const keys = getPathSegments(path);
@@ -32,6 +36,13 @@ function set(obj, path, value) {
 		"prototype"
 	];
 	if (keys.some((k) => UNSAFE_KEYS.includes(k))) return;
+	for (const key of keys) if (/^\d+$/.test(key)) {
+		const index = parseInt(key, 10);
+		if (index > MAX_ARRAY_INDEX) {
+			if (typeof console !== "undefined" && console.warn) console.warn(`[vue-hook-form] set(): Array index ${index} exceeds maximum allowed (${MAX_ARRAY_INDEX}). Path "${path}" was not set to prevent memory exhaustion.`);
+			return;
+		}
+	}
 	const lastKey = keys.pop();
 	let current = obj;
 	for (let i = 0; i < keys.length; i++) {
@@ -66,13 +77,22 @@ function generateId() {
 	const random = Math.random().toString(36).substring(2, 11);
 	return `field_${Date.now()}_${idCounter++}_${random}`;
 }
-function deepClone(obj) {
+function deepClone(obj, seen) {
 	if (obj === null || obj === void 0) return obj;
 	if (typeof obj !== "object") return obj;
 	if (obj instanceof Date) return new Date(obj.getTime());
-	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	if (!seen) seen = /* @__PURE__ */ new Map();
+	const existingClone = seen.get(obj);
+	if (existingClone !== void 0) return existingClone;
+	if (Array.isArray(obj)) {
+		const clonedArray = [];
+		seen.set(obj, clonedArray);
+		for (const item of obj) clonedArray.push(deepClone(item, seen));
+		return clonedArray;
+	}
 	const cloned = {};
-	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+	seen.set(obj, cloned);
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key], seen);
 	return cloned;
 }
 var proc = globalThis.process;
@@ -230,8 +250,8 @@ function createFormContext(options) {
 	if (isAsyncDefaults) {
 		const asyncFn = options.defaultValues;
 		asyncFn().then((values) => {
-			Object.assign(defaultValues, values);
-			Object.assign(formData, values);
+			Object.assign(defaultValues, deepClone(values));
+			Object.assign(formData, deepClone(values));
 			isLoading.value = false;
 		}).catch((error) => {
 			console.error("Failed to load async default values:", error);
@@ -240,8 +260,8 @@ function createFormContext(options) {
 			options.onDefaultValuesError?.(error);
 		});
 	} else if (options.defaultValues) {
-		Object.assign(defaultValues, options.defaultValues);
-		Object.assign(formData, defaultValues);
+		Object.assign(defaultValues, deepClone(options.defaultValues));
+		Object.assign(formData, deepClone(options.defaultValues));
 	}
 	const errors = (0, vue.shallowRef)({});
 	const touchedFields = (0, vue.shallowRef)({});
@@ -261,23 +281,24 @@ function createFormContext(options) {
 	const debounceTimers = /* @__PURE__ */ new Map();
 	const validationRequestIds = /* @__PURE__ */ new Map();
 	const resetGeneration = (0, vue.ref)(0);
-	const dirtyFieldCount = (0, vue.ref)(0);
-	const touchedFieldCount = (0, vue.ref)(0);
 	const validationCache = /* @__PURE__ */ new Map();
 	const schemaValidationTimers = /* @__PURE__ */ new Map();
+	const persistentErrorFields = /* @__PURE__ */ new Set();
+	const defaultValueHashes = /* @__PURE__ */ new Map();
 	const isDisabled = (0, vue.ref)(false);
+	const watchStopHandles = [];
 	if (options.disabled !== void 0) {
 		isDisabled.value = (0, vue.toValue)(options.disabled) ?? false;
-		(0, vue.watch)(() => (0, vue.toValue)(options.disabled), (newDisabled) => {
+		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.disabled), (newDisabled) => {
 			isDisabled.value = newDisabled ?? false;
-		});
+		}));
 	}
 	if (options.values !== void 0) {
 		const initialValues = (0, vue.toValue)(options.values);
 		if (initialValues && !isAsyncDefaults) {
 			for (const [key, value] of Object.entries(initialValues)) if (value !== void 0) set(formData, key, value);
 		}
-		(0, vue.watch)(() => (0, vue.toValue)(options.values), (newValues) => {
+		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.values), (newValues) => {
 			if (newValues) {
 				for (const [key, value] of Object.entries(newValues)) if (value !== void 0) {
 					set(formData, key, value);
@@ -290,14 +311,14 @@ function createFormContext(options) {
 					}
 				}
 			}
-		}, { deep: true });
+		}, { deep: true }));
 	}
 	if (options.errors !== void 0) {
 		const initialErrors = (0, vue.toValue)(options.errors);
 		if (initialErrors) externalErrors.value = initialErrors;
-		(0, vue.watch)(() => (0, vue.toValue)(options.errors), (newErrors) => {
+		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.errors), (newErrors) => {
 			externalErrors.value = newErrors || {};
-		}, { deep: true });
+		}, { deep: true }));
 	}
 	return {
 		formData,
@@ -322,25 +343,40 @@ function createFormContext(options) {
 		validationRequestIds,
 		resetGeneration,
 		isDisabled,
-		dirtyFieldCount,
-		touchedFieldCount,
 		validationCache,
 		schemaValidationTimers,
-		options
+		persistentErrorFields,
+		defaultValueHashes,
+		options,
+		cleanup: () => {
+			for (const stop of watchStopHandles) stop();
+		}
 	};
 }
 var uniqueIdCounter = 0;
+var circularRefMap = /* @__PURE__ */ new WeakMap();
 function hashValue(value) {
 	if (value === null) return "null";
 	if (value === void 0) return "undefined";
 	const type = typeof value;
 	if (type === "string") return `s:${value}`;
-	if (type === "number") return `n:${value}`;
+	if (type === "number") {
+		const num = value;
+		if (Number.isNaN(num)) return "n:NaN";
+		if (num === 0) return "n:0";
+		if (!Number.isFinite(num)) return `n:${num > 0 ? "Infinity" : "-Infinity"}`;
+		return `n:${num}`;
+	}
 	if (type === "boolean") return `b:${value}`;
 	if (type === "object") try {
 		return `o:${JSON.stringify(value)}`;
 	} catch {
-		return `o:_${++uniqueIdCounter}`;
+		let id = circularRefMap.get(value);
+		if (!id) {
+			id = String(++uniqueIdCounter);
+			circularRefMap.set(value, id);
+		}
+		return `o:_${id}`;
 	}
 	return `x:_${++uniqueIdCounter}`;
 }
@@ -375,7 +411,7 @@ function extractSubSchema(schema, path) {
 	let currentSchema = schema;
 	let hasEffects = false;
 	for (const segment of segments) {
-		if (!segment) continue;
+		if (!segment) return null;
 		if (hasChecks(currentSchema)) hasEffects = true;
 		const unwrapped = unwrapNonEffects(currentSchema);
 		if (hasChecks(unwrapped)) hasEffects = true;
@@ -442,10 +478,54 @@ function analyzeSchemaPath(schema, path) {
 	cache.set(path, result);
 	return result;
 }
-function clearFieldErrors$1(errors, fieldPath) {
-	const newErrors = { ...errors };
-	for (const key of Object.keys(newErrors)) if (key === fieldPath || key.startsWith(`${fieldPath}.`)) delete newErrors[key];
-	return newErrors;
+function markFieldTouched(touchedFields, fieldName) {
+	if (touchedFields.value[fieldName]) return;
+	touchedFields.value = {
+		...touchedFields.value,
+		[fieldName]: true
+	};
+}
+function clearFieldDirty(dirtyFields, fieldName) {
+	if (!(fieldName in dirtyFields.value)) return;
+	const newDirty = { ...dirtyFields.value };
+	delete newDirty[fieldName];
+	dirtyFields.value = newDirty;
+}
+function clearFieldTouched(touchedFields, fieldName) {
+	if (!(fieldName in touchedFields.value)) return;
+	const newTouched = { ...touchedFields.value };
+	delete newTouched[fieldName];
+	touchedFields.value = newTouched;
+}
+function clearFieldErrors(errors, fieldName) {
+	const currentErrors = errors.value;
+	const keys = Object.keys(currentErrors);
+	if (keys.length === 0) return;
+	const prefix = `${fieldName}.`;
+	const keysToDelete = [];
+	for (const key of keys) if (key === fieldName || key.startsWith(prefix)) keysToDelete.push(key);
+	if (keysToDelete.length === 0) return;
+	const newErrors = { ...currentErrors };
+	for (const key of keysToDelete) delete newErrors[key];
+	errors.value = newErrors;
+}
+function updateFieldDirtyState(dirtyFields, defaultValues, defaultValueHashes, fieldName, currentValue) {
+	let defaultHash = defaultValueHashes.get(fieldName);
+	if (defaultHash === void 0) {
+		defaultHash = hashValue(get(defaultValues, fieldName));
+		defaultValueHashes.set(fieldName, defaultHash);
+	}
+	const isDirty = hashValue(currentValue) !== defaultHash;
+	const wasDirty = dirtyFields.value[fieldName] === true;
+	if (isDirty && !wasDirty) dirtyFields.value = {
+		...dirtyFields.value,
+		[fieldName]: true
+	};
+	else if (!isDirty && wasDirty) {
+		const newDirty = { ...dirtyFields.value };
+		delete newDirty[fieldName];
+		dirtyFields.value = newDirty;
+	}
 }
 function setValidating(ctx, fieldPath, isValidating) {
 	const newSet = new Set(ctx.validatingFields.value);
@@ -539,37 +619,43 @@ function createValidation(ctx) {
 		}
 		ctx.pendingErrors.delete(fieldPath);
 		applyNativeValidation(fieldPath, null);
-		return clearFieldErrors$1(ctx.errors.value, fieldPath);
+		if (ctx.persistentErrorFields.has(fieldPath)) return;
+		clearFieldErrors(ctx.errors, fieldPath);
 	}
 	function clearAllPendingErrors() {
 		for (const timer of ctx.errorDelayTimers.values()) clearTimeout(timer);
 		ctx.errorDelayTimers.clear();
 		ctx.pendingErrors.clear();
 	}
-	async function validateFieldPartial(fieldPath, subSchema, valueHash, criteriaMode, generationAtStart) {
+	async function validateFieldPartial(fieldPath, subSchema, valueHash, cacheKey, criteriaMode, generationAtStart) {
 		const fieldValue = get(ctx.formData, fieldPath);
 		setValidating(ctx, fieldPath, true);
 		try {
 			const result = await subSchema.safeParseAsync(fieldValue);
 			if (ctx.resetGeneration.value !== generationAtStart) return true;
 			if (result.success) {
-				ctx.errors.value = cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(fieldPath, {
+				cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(cacheKey, {
 					hash: valueHash,
 					isValid: true
 				});
 				return true;
 			}
-			const fieldErrors = result.error.issues.map((issue) => ({
-				...issue,
-				path: fieldPath.split(".").concat(issue.path.map(String))
-			}));
-			ctx.errors.value = cancelError(fieldPath);
+			const fieldSegments = fieldPath.split(".");
+			const fieldErrors = result.error.issues.map((issue) => {
+				const issuePath = issue.path.map(String);
+				const alreadyPrefixed = issuePath.length >= fieldSegments.length && fieldSegments.every((seg, i) => issuePath[i] === seg);
+				return {
+					...issue,
+					path: alreadyPrefixed ? issuePath : fieldSegments.concat(issuePath)
+				};
+			});
+			cancelError(fieldPath);
 			const grouped = groupErrorsByPath(fieldErrors);
 			const errorBatch = [];
 			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
 			scheduleErrorsBatch(errorBatch);
-			if (valueHash) ctx.validationCache.set(fieldPath, {
+			if (valueHash) ctx.validationCache.set(cacheKey, {
 				hash: valueHash,
 				isValid: false
 			});
@@ -578,14 +664,14 @@ function createValidation(ctx) {
 			setValidating(ctx, fieldPath, false);
 		}
 	}
-	async function validateFieldFull(fieldPath, valueHash, criteriaMode, generationAtStart) {
+	async function validateFieldFull(fieldPath, valueHash, cacheKey, criteriaMode, generationAtStart) {
 		setValidating(ctx, fieldPath, true);
 		try {
 			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
 			if (ctx.resetGeneration.value !== generationAtStart) return true;
 			if (result.success) {
-				ctx.errors.value = cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(fieldPath, {
+				cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(cacheKey, {
 					hash: valueHash,
 					isValid: true
 				});
@@ -596,19 +682,19 @@ function createValidation(ctx) {
 				return path === fieldPath || path.startsWith(`${fieldPath}.`);
 			});
 			if (fieldErrors.length === 0) {
-				ctx.errors.value = cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(fieldPath, {
+				cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(cacheKey, {
 					hash: valueHash,
 					isValid: true
 				});
 				return true;
 			}
-			ctx.errors.value = cancelError(fieldPath);
+			cancelError(fieldPath);
 			const grouped = groupErrorsByPath(fieldErrors);
 			const errorBatch = [];
 			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
 			scheduleErrorsBatch(errorBatch);
-			if (valueHash) ctx.validationCache.set(fieldPath, {
+			if (valueHash) ctx.validationCache.set(cacheKey, {
 				hash: valueHash,
 				isValid: false
 			});
@@ -623,11 +709,16 @@ function createValidation(ctx) {
 		let valueHash;
 		if (fieldPath) {
 			valueHash = hashValue(get(ctx.formData, fieldPath));
-			const cached = ctx.validationCache.get(fieldPath);
-			if (cached && cached.hash === valueHash) return cached.isValid;
 			const analysis = analyzeSchemaPath(ctx.options.schema, fieldPath);
-			if (analysis.canPartialValidate && analysis.subSchema) return validateFieldPartial(fieldPath, analysis.subSchema, valueHash, criteriaMode, generationAtStart);
-			return validateFieldFull(fieldPath, valueHash, criteriaMode, generationAtStart);
+			const usePartial = analysis.canPartialValidate && analysis.subSchema;
+			const cacheKey = `${fieldPath}:${usePartial ? "partial" : "full"}`;
+			const cached = ctx.validationCache.get(cacheKey);
+			if (cached && cached.hash === valueHash && cached.isValid) {
+				cancelError(fieldPath);
+				return true;
+			}
+			if (usePartial) return validateFieldPartial(fieldPath, analysis.subSchema, valueHash, cacheKey, criteriaMode, generationAtStart);
+			return validateFieldFull(fieldPath, valueHash, cacheKey, criteriaMode, generationAtStart);
 		}
 		const validatingKey = "_form";
 		setValidating(ctx, validatingKey, true);
@@ -658,47 +749,31 @@ function createValidation(ctx) {
 		clearAllPendingErrors
 	};
 }
-function markFieldDirty(dirtyFields, dirtyFieldCount, fieldName) {
-	if (dirtyFields.value[fieldName]) return;
-	dirtyFields.value = {
-		...dirtyFields.value,
-		[fieldName]: true
-	};
-	dirtyFieldCount.value++;
-}
-function markFieldTouched(touchedFields, touchedFieldCount, fieldName) {
-	if (touchedFields.value[fieldName]) return;
-	touchedFields.value = {
-		...touchedFields.value,
-		[fieldName]: true
-	};
-	touchedFieldCount.value++;
-}
-function clearFieldDirty(dirtyFields, dirtyFieldCount, fieldName) {
-	if (!(fieldName in dirtyFields.value)) return;
-	const newDirty = { ...dirtyFields.value };
-	delete newDirty[fieldName];
-	dirtyFields.value = newDirty;
-	dirtyFieldCount.value--;
+var VALID_MODES = [
+	"onSubmit",
+	"onBlur",
+	"onChange",
+	"onTouched"
+];
+function validateMode(mode, paramName) {
+	if (__DEV__ && !VALID_MODES.includes(mode)) warnOnce(`Invalid ${paramName}: "${mode}". Expected one of: ${VALID_MODES.join(", ")}`, `invalid-mode-${mode}`);
 }
-function clearFieldTouched(touchedFields, touchedFieldCount, fieldName) {
-	if (!(fieldName in touchedFields.value)) return;
-	const newTouched = { ...touchedFields.value };
-	delete newTouched[fieldName];
-	touchedFields.value = newTouched;
-	touchedFieldCount.value--;
+function shouldValidateOnChange(mode, isTouched, reValidateMode, hasSubmitted) {
+	if (__DEV__) {
+		validateMode(mode, "validation mode");
+		if (reValidateMode) validateMode(reValidateMode, "reValidateMode");
+	}
+	if (mode === "onChange") return true;
+	if (mode === "onTouched" && isTouched) return true;
+	if (hasSubmitted === true && reValidateMode === "onChange") return true;
+	return false;
 }
-function clearFieldErrors(errors, fieldName) {
-	const currentErrors = errors.value;
-	const keys = Object.keys(currentErrors);
-	if (keys.length === 0) return;
-	const prefix = `${fieldName}.`;
-	const keysToDelete = [];
-	for (const key of keys) if (key === fieldName || key.startsWith(prefix)) keysToDelete.push(key);
-	if (keysToDelete.length === 0) return;
-	const newErrors = { ...currentErrors };
-	for (const key of keysToDelete) delete newErrors[key];
-	errors.value = newErrors;
+function shouldValidateOnBlur(mode, hasSubmitted, reValidateMode) {
+	if (__DEV__) {
+		validateMode(mode, "validation mode");
+		if (reValidateMode) validateMode(reValidateMode, "reValidateMode");
+	}
+	return mode === "onBlur" || mode === "onTouched" || hasSubmitted && (reValidateMode === "onBlur" || reValidateMode === "onTouched");
 }
 var validationRequestCounter = 0;
 function createFieldRegistration(ctx, validate) {
@@ -739,11 +814,14 @@ function createFieldRegistration(ctx, validate) {
 			};
 			const onInput = async (e) => {
 				const target = e.target;
-				const value = target.type === "checkbox" ? target.checked : target.value;
+				let value;
+				if (target.type === "checkbox") value = target.checked;
+				else if (target.type === "number" || target.type === "range") value = target.valueAsNumber;
+				else value = target.value;
 				set(ctx.formData, name, value);
-				markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+				updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, value);
 				const fieldOpts = ctx.fieldOptions.get(name);
-				if (ctx.options.mode === "onChange" || ctx.options.mode === "onTouched" && ctx.touchedFields.value[name] || ctx.touchedFields.value[name] && ctx.options.reValidateMode === "onChange") {
+				if (shouldValidateOnChange(ctx.options.mode ?? "onSubmit", ctx.touchedFields.value[name] === true, ctx.options.reValidateMode, ctx.submitCount.value > 0)) {
 					const validationDebounceMs = ctx.options.validationDebounce || 0;
 					if (validationDebounceMs > 0) {
 						const existingTimer = ctx.schemaValidationTimers.get(name);
@@ -776,15 +854,18 @@ function createFieldRegistration(ctx, validate) {
 						const timer = setTimeout(async () => {
 							ctx.debounceTimers.delete(name);
 							await runCustomValidation(name, value, requestId, resetGenAtStart);
-							ctx.validationRequestIds.delete(name);
+							if (ctx.validationRequestIds.get(name) === requestId) ctx.validationRequestIds.delete(name);
 						}, debounceMs);
 						ctx.debounceTimers.set(name, timer);
-					} else await runCustomValidation(name, value, requestId, resetGenAtStart);
+					} else {
+						await runCustomValidation(name, value, requestId, resetGenAtStart);
+						if (ctx.validationRequestIds.get(name) === requestId) ctx.validationRequestIds.delete(name);
+					}
 				}
 			};
 			const onBlur = async (_e) => {
-				markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
-				if (ctx.options.mode === "onBlur" || ctx.options.mode === "onTouched" || ctx.submitCount.value > 0 && ctx.options.reValidateMode === "onBlur") {
+				markFieldTouched(ctx.touchedFields, name);
+				if (shouldValidateOnBlur(ctx.options.mode ?? "onSubmit", ctx.submitCount.value > 0, ctx.options.reValidateMode)) {
 					await validate(name);
 					const fieldOpts = ctx.fieldOptions.get(name);
 					if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
@@ -817,15 +898,21 @@ function createFieldRegistration(ctx, validate) {
 						clearTimeout(schemaTimer);
 						ctx.schemaValidationTimers.delete(name);
 					}
+					const errorTimer = ctx.errorDelayTimers.get(name);
+					if (errorTimer) {
+						clearTimeout(errorTimer);
+						ctx.errorDelayTimers.delete(name);
+					}
+					ctx.pendingErrors.delete(name);
 					ctx.validationRequestIds.delete(name);
+					ctx.fieldRefs.delete(name);
+					ctx.fieldOptions.delete(name);
+					ctx.fieldHandlers.delete(name);
 					if (opts?.shouldUnregister ?? ctx.options.shouldUnregister ?? false) {
 						unset(ctx.formData, name);
 						clearFieldErrors(ctx.errors, name);
-						clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
-						clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-						ctx.fieldRefs.delete(name);
-						ctx.fieldOptions.delete(name);
-						ctx.fieldHandlers.delete(name);
+						clearFieldTouched(ctx.touchedFields, name);
+						clearFieldDirty(ctx.dirtyFields, name);
 					}
 				}
 			};
@@ -846,7 +933,7 @@ function createFieldRegistration(ctx, validate) {
 				get: () => get(ctx.formData, name),
 				set: (val) => {
 					set(ctx.formData, name, val);
-					markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+					updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, val);
 				}
 			}) }
 		};
@@ -855,8 +942,8 @@ function createFieldRegistration(ctx, validate) {
 		const opts = options || {};
 		if (!opts.keepValue) unset(ctx.formData, name);
 		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
-		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
+		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, name);
 		ctx.fieldRefs.delete(name);
 		ctx.fieldOptions.delete(name);
 		ctx.fieldHandlers.delete(name);
@@ -871,6 +958,8 @@ function createFieldRegistration(ctx, validate) {
 			ctx.schemaValidationTimers.delete(name);
 		}
 		ctx.validationRequestIds.delete(name);
+		ctx.validationCache.delete(`${name}:partial`);
+		ctx.validationCache.delete(`${name}:full`);
 	}
 	return {
 		register,
@@ -960,10 +1049,32 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 		const normalizeToArray = (value) => {
 			return Array.isArray(value) ? value : [value];
 		};
+		const clearValidationCache = () => {
+			for (const key of ctx.validationCache.keys()) {
+				const colonIndex = key.lastIndexOf(":");
+				const fieldPath = colonIndex > 0 ? key.slice(0, colonIndex) : key;
+				if (fieldPath === name || fieldPath.startsWith(`${name}.`)) ctx.validationCache.delete(key);
+			}
+		};
+		const validateIfNeeded = () => {
+			const isTouched = ctx.touchedFields.value[name] === true;
+			const hasSubmitted = ctx.submitCount.value > 0;
+			if (shouldValidateOnChange(ctx.options.mode ?? "onSubmit", isTouched, ctx.options.reValidateMode, hasSubmitted)) validate(name);
+		};
+		const ensureSync = () => {
+			const currentValues = get(ctx.formData, name) || [];
+			if (fa.items.value.length !== currentValues.length) {
+				if (__DEV__) console.warn(`[vue-hook-form] Field array out of sync with formData. Rebuilding items array (items: ${fa.items.value.length}, formData: ${currentValues.length})`);
+				fa.items.value = currentValues.map(() => createItem(generateId()));
+				rebuildIndexCache();
+			}
+			return currentValues;
+		};
 		const append = (value, focusOptions) => {
+			clearValidationCache();
 			const values = normalizeToArray(value);
 			if (values.length === 0) return true;
-			const currentValues = get(ctx.formData, name) || [];
+			const currentValues = ensureSync();
 			const insertIndex = currentValues.length;
 			const rules = fa.rules;
 			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
@@ -978,15 +1089,16 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...fa.items.value, ...newItems];
 			appendToCache(insertIndex);
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			handleFocus(insertIndex, values.length, focusOptions);
 			return true;
 		};
 		const prepend = (value, focusOptions) => {
+			clearValidationCache();
 			const values = normalizeToArray(value);
 			if (values.length === 0) return true;
-			const currentValues = get(ctx.formData, name) || [];
+			const currentValues = ensureSync();
 			const rules = fa.rules;
 			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
 				if (__DEV__) warnArrayOperationRejected("prepend", name, "maxLength", {
@@ -1000,13 +1112,14 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...newItems, ...fa.items.value];
 			updateCacheAfterInsert(0, values.length);
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			handleFocus(0, values.length, focusOptions);
 			return true;
 		};
 		const update = (index, value) => {
-			const currentValues = get(ctx.formData, name) || [];
+			clearValidationCache();
+			const currentValues = ensureSync();
 			if (index < 0 || index >= currentValues.length) {
 				if (__DEV__) warnArrayIndexOutOfBounds("update", name, index, currentValues.length);
 				return false;
@@ -1014,12 +1127,13 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const newValues = [...currentValues];
 			newValues[index] = value;
 			set(ctx.formData, name, newValues);
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const removeAt = (index) => {
-			const currentValues = get(ctx.formData, name) || [];
+			clearValidationCache();
+			const currentValues = ensureSync();
 			if (index < 0 || index >= currentValues.length) {
 				if (__DEV__) warnArrayIndexOutOfBounds("remove", name, index, currentValues.length);
 				return false;
@@ -1037,14 +1151,15 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const keyToRemove = fa.items.value[index]?.key;
 			fa.items.value = fa.items.value.filter((item) => item.key !== keyToRemove);
 			if (keyToRemove) updateCacheAfterRemove(keyToRemove, index);
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const insert = (index, value, focusOptions) => {
+			clearValidationCache();
 			const values = normalizeToArray(value);
 			if (values.length === 0) return true;
-			const currentValues = get(ctx.formData, name) || [];
+			const currentValues = ensureSync();
 			const rules = fa.rules;
 			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
 				if (__DEV__) warnArrayOperationRejected("insert", name, "maxLength", {
@@ -1053,27 +1168,31 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				});
 				return false;
 			}
-			const clampedIndex = Math.max(0, Math.min(index, currentValues.length));
+			if (index < 0 || index > currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("insert", name, index, currentValues.length);
+				return false;
+			}
 			const newValues = [
-				...currentValues.slice(0, clampedIndex),
+				...currentValues.slice(0, index),
 				...values,
-				...currentValues.slice(clampedIndex)
+				...currentValues.slice(index)
 			];
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [
-				...fa.items.value.slice(0, clampedIndex),
+				...fa.items.value.slice(0, index),
 				...newItems,
-				...fa.items.value.slice(clampedIndex)
+				...fa.items.value.slice(index)
 			];
-			updateCacheAfterInsert(clampedIndex, values.length);
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
-			handleFocus(clampedIndex, values.length, focusOptions);
+			updateCacheAfterInsert(index, values.length);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
+			handleFocus(index, values.length, focusOptions);
 			return true;
 		};
 		const swap = (indexA, indexB) => {
-			const currentValues = get(ctx.formData, name) || [];
+			clearValidationCache();
+			const currentValues = ensureSync();
 			if (indexA < 0 || indexB < 0 || indexA >= currentValues.length || indexB >= currentValues.length) {
 				if (__DEV__) warnArrayIndexOutOfBounds("swap", name, indexA < 0 || indexA >= currentValues.length ? indexA : indexB, currentValues.length);
 				return false;
@@ -1090,51 +1209,52 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				fa.items.value = newItems;
 				swapInCache(indexA, indexB);
 			}
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const move = (from, to) => {
-			const currentValues = get(ctx.formData, name) || [];
-			if (from < 0 || from >= currentValues.length || to < 0) {
+			clearValidationCache();
+			const currentValues = ensureSync();
+			if (from < 0 || from >= currentValues.length || to < 0 || to >= currentValues.length) {
 				if (__DEV__) warnArrayIndexOutOfBounds("move", name, from < 0 || from >= currentValues.length ? from : to, currentValues.length);
 				return false;
 			}
 			const newValues = [...currentValues];
 			const [removed] = newValues.splice(from, 1);
 			if (removed !== void 0) {
-				const clampedTo = Math.min(to, newValues.length);
-				newValues.splice(clampedTo, 0, removed);
+				newValues.splice(to, 0, removed);
 				set(ctx.formData, name, newValues);
 			}
 			const newItems = [...fa.items.value];
 			const [removedItem] = newItems.splice(from, 1);
 			if (removedItem) {
-				const clampedTo = Math.min(to, newItems.length);
-				newItems.splice(clampedTo, 0, removedItem);
+				newItems.splice(to, 0, removedItem);
 				fa.items.value = newItems;
-				const minIdx = Math.min(from, clampedTo);
-				const maxIdx = Math.max(from, clampedTo);
+				const minIdx = Math.min(from, to);
+				const maxIdx = Math.max(from, to);
 				const items = fa.items.value;
 				for (let i = minIdx; i <= maxIdx; i++) {
 					const item = items[i];
 					if (item) indexCache.set(item.key, i);
 				}
 			}
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const replace = (newValues) => {
+			clearValidationCache();
 			if (!Array.isArray(newValues)) return false;
 			set(ctx.formData, name, newValues);
 			fa.items.value = newValues.map(() => createItem(generateId()));
 			rebuildIndexCache();
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const removeAll = () => {
+			clearValidationCache();
 			const rules = fa.rules;
 			if (rules?.minLength && rules.minLength.value > 0) {
 				if (__DEV__) warnArrayOperationRejected("removeAll", name, "minLength", {
@@ -1146,12 +1266,13 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, []);
 			fa.items.value = [];
 			indexCache.clear();
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		const removeMany = (indices) => {
-			const currentValues = get(ctx.formData, name) || [];
+			clearValidationCache();
+			const currentValues = ensureSync();
 			const validIndices = indices.filter((i) => i >= 0 && i < currentValues.length);
 			if (validIndices.length === 0) return true;
 			const rules = fa.rules;
@@ -1173,8 +1294,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			fa.items.value.forEach((item, idx) => {
 				indexCache.set(item.key, idx);
 			});
-			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-			if (ctx.options.mode === "onChange") validate(name);
+			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
+			validateIfNeeded();
 			return true;
 		};
 		return {
@@ -1197,7 +1318,13 @@ function syncUncontrolledInputs(fieldRefs, fieldOptions, formData) {
 	for (const [name, fieldRef] of Array.from(fieldRefs.entries())) {
 		const el = fieldRef.value;
 		if (el) {
-			if (!fieldOptions.get(name)?.controlled) set(formData, name, el.type === "checkbox" ? el.checked : el.value);
+			if (!fieldOptions.get(name)?.controlled) {
+				let value;
+				if (el.type === "checkbox") value = el.checked;
+				else if (el.type === "number" || el.type === "range") value = el.valueAsNumber;
+				else value = el.value;
+				set(formData, name, value);
+			}
 		}
 	}
 }
@@ -1207,6 +1334,10 @@ function updateDomElement(el, value) {
 }
 function useForm(options) {
 	const ctx = createFormContext(options);
+	let isSubmissionLocked = false;
+	(0, vue.onUnmounted)(() => {
+		ctx.cleanup();
+	});
 	const { validate, clearAllPendingErrors } = createValidation(ctx);
 	const { register, unregister } = createFieldRegistration(ctx, validate);
 	function setFocus(name, focusOptions) {
@@ -1249,10 +1380,10 @@ function useForm(options) {
 		};
 		return cachedMergedErrors;
 	}
-	const isDirtyComputed = (0, vue.computed)(() => ctx.dirtyFieldCount.value > 0);
+	const isDirtyComputed = (0, vue.computed)(() => Object.keys(ctx.dirtyFields.value).length > 0);
 	const errorsComputed = (0, vue.computed)(() => getMergedErrors());
 	const isValidComputed = (0, vue.computed)(() => {
-		if (!(ctx.submitCount.value > 0 || ctx.touchedFieldCount.value > 0)) return false;
+		if (!(ctx.submitCount.value > 0 || Object.keys(ctx.touchedFields.value).length > 0)) return false;
 		return Object.keys(errorsComputed.value).length === 0;
 	});
 	const isReadyComputed = (0, vue.computed)(() => !ctx.isLoading.value);
@@ -1310,7 +1441,8 @@ function useForm(options) {
 		return async (e) => {
 			e.preventDefault();
 			if (ctx.isDisabled.value) return;
-			if (ctx.isSubmitting.value) return;
+			if (isSubmissionLocked) return;
+			isSubmissionLocked = true;
 			ctx.isSubmitting.value = true;
 			ctx.submitCount.value++;
 			ctx.isSubmitSuccessful.value = false;
@@ -1328,6 +1460,7 @@ function useForm(options) {
 				}
 			} finally {
 				ctx.isSubmitting.value = false;
+				isSubmissionLocked = false;
 			}
 		};
 	}
@@ -1341,8 +1474,9 @@ function useForm(options) {
 			}
 		}
 		set(ctx.formData, name, value);
-		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
+		if (setValueOptions?.shouldDirty === false) clearFieldDirty(ctx.dirtyFields, name);
+		else updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, value);
+		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, name);
 		if (!ctx.fieldOptions.get(name)?.controlled) {
 			const fieldRef = ctx.fieldRefs.get(name);
 			if (fieldRef?.value) updateDomElement(fieldRef.value, value);
@@ -1351,25 +1485,28 @@ function useForm(options) {
 	}
 	function reset(values, resetOptions) {
 		const opts = resetOptions || {};
+		ctx.validationCache.clear();
 		ctx.resetGeneration.value++;
 		clearAllPendingErrors();
 		ctx.validatingFields.value = /* @__PURE__ */ new Set();
-		ctx.validationCache.clear();
 		for (const timer of ctx.schemaValidationTimers.values()) clearTimeout(timer);
 		ctx.schemaValidationTimers.clear();
-		if (!opts.keepDefaultValues && values) Object.assign(ctx.defaultValues, values);
+		for (const timer of ctx.debounceTimers.values()) clearTimeout(timer);
+		ctx.debounceTimers.clear();
+		ctx.validationRequestIds.clear();
+		if (!opts.keepDefaultValues && values) {
+			Object.assign(ctx.defaultValues, values);
+			ctx.defaultValueHashes.clear();
+		}
 		Object.keys(ctx.formData).forEach((key) => delete ctx.formData[key]);
 		const newValues = deepClone(values || ctx.defaultValues);
 		Object.assign(ctx.formData, newValues);
-		if (!opts.keepErrors) ctx.errors.value = {};
-		if (!opts.keepTouched) {
-			ctx.touchedFields.value = {};
-			ctx.touchedFieldCount.value = 0;
-		}
-		if (!opts.keepDirty) {
-			ctx.dirtyFields.value = {};
-			ctx.dirtyFieldCount.value = 0;
+		if (!opts.keepErrors) {
+			ctx.errors.value = {};
+			ctx.persistentErrorFields.clear();
 		}
+		if (!opts.keepTouched) ctx.touchedFields.value = {};
+		if (!opts.keepDirty) ctx.dirtyFields.value = {};
 		if (!opts.keepSubmitCount) ctx.submitCount.value = 0;
 		if (!opts.keepIsSubmitting) ctx.isSubmitting.value = false;
 		if (!opts.keepIsSubmitSuccessful) ctx.isSubmitSuccessful.value = false;
@@ -1394,6 +1531,8 @@ function useForm(options) {
 		}
 		const opts = resetFieldOptions || {};
 		ctx.resetGeneration.value++;
+		ctx.validationCache.delete(`${name}:partial`);
+		ctx.validationCache.delete(`${name}:full`);
 		const errorTimer = ctx.errorDelayTimers.get(name);
 		if (errorTimer) {
 			clearTimeout(errorTimer);
@@ -1402,12 +1541,15 @@ function useForm(options) {
 		ctx.pendingErrors.delete(name);
 		let defaultValue = opts.defaultValue;
 		if (defaultValue === void 0) defaultValue = get(ctx.defaultValues, name);
-		else set(ctx.defaultValues, name, defaultValue);
+		else {
+			set(ctx.defaultValues, name, defaultValue);
+			ctx.defaultValueHashes.set(name, hashValue(defaultValue));
+		}
 		const clonedValue = defaultValue !== void 0 ? deepClone(defaultValue) : void 0;
 		set(ctx.formData, name, clonedValue);
 		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
-		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
+		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, name);
+		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
 		if (!ctx.fieldOptions.get(name)?.controlled) {
 			const fieldRef = ctx.fieldRefs.get(name);
 			if (fieldRef?.value) updateDomElement(fieldRef.value, clonedValue ?? (fieldRef.value.type === "checkbox" ? false : ""));
@@ -1450,10 +1592,16 @@ function useForm(options) {
 		}
 		if (name === void 0) {
 			ctx.errors.value = {};
+			ctx.externalErrors.value = {};
+			ctx.persistentErrorFields.clear();
 			return;
 		}
 		const fieldsToClean = Array.isArray(name) ? name : [name];
-		for (const field of fieldsToClean) clearFieldErrors(ctx.errors, field);
+		for (const field of fieldsToClean) {
+			clearFieldErrors(ctx.errors, field);
+			clearFieldErrors(ctx.externalErrors, field);
+			ctx.persistentErrorFields.delete(field);
+		}
 	}
 	function setError(name, error) {
 		const newErrors = { ...ctx.errors.value };
@@ -1462,6 +1610,7 @@ function useForm(options) {
 			message: error.message
 		} : error.message);
 		ctx.errors.value = newErrors;
+		if (error.persistent) ctx.persistentErrorFields.add(name);
 	}
 	function setErrors(errors, options$1) {
 		const newErrors = options$1?.shouldReplace ? {} : { ...ctx.errors.value };
@@ -1523,7 +1672,7 @@ function useForm(options) {
 			error
 		};
 	}
-	async function trigger(name) {
+	async function trigger(name, options$1) {
 		if (__DEV__ && name) {
 			const names = Array.isArray(name) ? name : [name];
 			for (const n of names) {
@@ -1535,6 +1684,7 @@ function useForm(options) {
 				}
 			}
 		}
+		if (options$1?.markAsSubmitted) ctx.submitCount.value++;
 		if (name === void 0) return await validate();
 		if (Array.isArray(name)) {
 			let allValid = true;
@@ -1562,7 +1712,11 @@ function useForm(options) {
 		getValues,
 		getFieldState,
 		trigger,
-		setFocus
+		setFocus,
+		options: {
+			mode: ctx.options.mode ?? "onSubmit",
+			reValidateMode: ctx.options.reValidateMode
+		}
 	};
 }
 const FormContextKey = Symbol("FormContext");
@@ -1601,10 +1755,24 @@ function useController(options) {
 		}
 	});
 	const onChange = (newValue) => {
-		form.setValue(name, newValue);
+		const isTouched = form.formState.value.touchedFields[name] === true;
+		const hasSubmitted = form.formState.value.submitCount > 0;
+		const mode = form.options.mode ?? "onSubmit";
+		const reValidateMode = form.options.reValidateMode;
+		const shouldValidate = shouldValidateOnChange(mode, isTouched, reValidateMode, hasSubmitted);
+		form.setValue(name, newValue, { shouldValidate });
 	};
 	const onBlur = () => {
-		form.trigger(name);
+		const hasSubmitted = form.formState.value.submitCount > 0;
+		const mode = form.options.mode ?? "onSubmit";
+		const reValidateMode = form.options.reValidateMode;
+		const shouldValidate = shouldValidateOnBlur(mode, hasSubmitted, reValidateMode);
+		const currentValue = form.getValues(name);
+		form.setValue(name, currentValue, {
+			shouldTouch: true,
+			shouldValidate,
+			shouldDirty: false
+		});
 	};
 	const refCallback = (el) => {
 		elementRef.value = el;
@@ -1641,8 +1809,13 @@ function isFieldError(error) {
 	return typeof error === "object" && error !== null && "type" in error && "message" in error && typeof error.type === "string" && typeof error.message === "string";
 }
 exports.FormContextKey = FormContextKey;
+exports.clearPathCache = clearPathCache;
+exports.generateId = generateId;
+exports.get = get;
 exports.isFieldError = isFieldError;
 exports.provideForm = provideForm;
+exports.set = set;
+exports.unset = unset;
 exports.useController = useController;
 exports.useForm = useForm;
 exports.useFormContext = useFormContext;