@vuehookform/core 0.3.3 → 0.4.0

package/dist/vuehookform.cjs

@@ -1,8 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let vue = require("vue");
+var pathCache = /* @__PURE__ */ new Map();
+var PATH_CACHE_MAX_SIZE = 256;
+function getPathSegments(path) {
+	let segments = pathCache.get(path);
+	if (segments) return segments;
+	segments = path.split(".");
+	if (pathCache.size >= PATH_CACHE_MAX_SIZE) {
+		const firstKey = pathCache.keys().next().value;
+		if (firstKey !== void 0) pathCache.delete(firstKey);
+	}
+	pathCache.set(path, segments);
+	return segments;
+}
 function get(obj, path) {
 	if (!path || obj === null || obj === void 0) return obj;
-	const keys = path.split(".");
+	const keys = getPathSegments(path);
 	let result = obj;
 	for (const key of keys) {
 		if (result === null || result === void 0) return;
@@ -12,7 +25,7 @@ function get(obj, path) {
 }
 function set(obj, path, value) {
 	if (!path) return;
-	const keys = path.split(".");
+	const keys = getPathSegments(path).slice();
 	const UNSAFE_KEYS = [
 		"__proto__",
 		"constructor",
@@ -37,7 +50,7 @@ function set(obj, path, value) {
 }
 function unset(obj, path) {
 	if (!path) return;
-	const keys = path.split(".");
+	const keys = getPathSegments(path).slice();
 	const lastKey = keys.pop();
 	let current = obj;
 	for (const key of keys) {
@@ -53,6 +66,15 @@ function generateId() {
 	const random = Math.random().toString(36).substring(2, 11);
 	return `field_${Date.now()}_${idCounter++}_${random}`;
 }
+function deepClone(obj) {
+	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));
+	const cloned = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+	return cloned;
+}
 var proc = globalThis.process;
 const __DEV__ = proc?.env?.NODE_ENV !== "production";
 var warnedMessages = /* @__PURE__ */ new Set();
@@ -82,7 +104,7 @@ function traverseSchemaPath(schema, path) {
 		const segment = segments[i];
 		if (!segment) continue;
 		currentSchema = unwrapSchema(currentSchema);
-		if (isZodObject(currentSchema)) {
+		if (isZodObject$1(currentSchema)) {
 			const shape = currentSchema.shape;
 			if (segment in shape) {
 				const nextSchema = shape[segment];
@@ -97,7 +119,7 @@ function traverseSchemaPath(schema, path) {
 				segmentIndex: i
 			};
 		}
-		if (isZodArray(currentSchema) && /^\d+$/.test(segment)) {
+		if (isZodArray$1(currentSchema) && /^\d+$/.test(segment)) {
 			currentSchema = currentSchema.element;
 			continue;
 		}
@@ -127,7 +149,7 @@ function isArrayFieldInSchema(schema, path) {
 	try {
 		const result = traverseSchemaPath(schema, path);
 		if ("error" in result) return null;
-		return isZodArray(unwrapSchema(result.schema));
+		return isZodArray$1(unwrapSchema(result.schema));
 	} catch {
 		return null;
 	}
@@ -180,22 +202,22 @@ function warnArrayIndexOutOfBounds(operation, path, index, length) {
 	if (!__DEV__) return;
 	warn(`${operation}() on "${path}": Index ${index} is out of bounds (array length: ${length}). Operation was silently ignored.`);
 }
-function getDefProp(schema, prop) {
+function getDefProp$1(schema, prop) {
 	return schema.def[prop];
 }
 function getTypeName(schema) {
-	return getDefProp(schema, "typeName");
+	return getDefProp$1(schema, "typeName");
 }
-function isZodObject(schema) {
+function isZodObject$1(schema) {
 	return getTypeName(schema) === "ZodObject";
 }
-function isZodArray(schema) {
+function isZodArray$1(schema) {
 	return getTypeName(schema) === "ZodArray";
 }
 function unwrapSchema(schema) {
 	const typeName = getTypeName(schema);
-	const innerType = getDefProp(schema, "innerType");
-	const schemaType = getDefProp(schema, "schema");
+	const innerType = getDefProp$1(schema, "innerType");
+	const schemaType = getDefProp$1(schema, "schema");
 	if ((typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodDefault") && innerType) return unwrapSchema(innerType);
 	if (typeName === "ZodEffects" && schemaType) return unwrapSchema(schemaType);
 	return schema;
@@ -228,7 +250,7 @@ function createFormContext(options) {
 	const submitCount = (0, vue.ref)(0);
 	const defaultValuesError = (0, vue.ref)(null);
 	const isSubmitSuccessful = (0, vue.ref)(false);
-	const validatingFields = (0, vue.shallowRef)({});
+	const validatingFields = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
 	const externalErrors = (0, vue.shallowRef)({});
 	const errorDelayTimers = /* @__PURE__ */ new Map();
 	const pendingErrors = /* @__PURE__ */ new Map();
@@ -239,6 +261,10 @@ 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 isDisabled = (0, vue.ref)(false);
 	if (options.disabled !== void 0) {
 		isDisabled.value = (0, vue.toValue)(options.disabled) ?? false;
@@ -296,24 +322,136 @@ function createFormContext(options) {
 		validationRequestIds,
 		resetGeneration,
 		isDisabled,
+		dirtyFieldCount,
+		touchedFieldCount,
+		validationCache,
+		schemaValidationTimers,
 		options
 	};
 }
+var uniqueIdCounter = 0;
+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 === "boolean") return `b:${value}`;
+	if (type === "object") try {
+		return `o:${JSON.stringify(value)}`;
+	} catch {
+		return `o:_${++uniqueIdCounter}`;
+	}
+	return `x:_${++uniqueIdCounter}`;
+}
+function getDefType(schema) {
+	return schema._def?.type;
+}
+function getDefProp(schema, prop) {
+	return schema._def?.[prop];
+}
+function isZodObject(schema) {
+	return getDefType(schema) === "object";
+}
+function isZodArray(schema) {
+	return getDefType(schema) === "array";
+}
+function hasChecks(schema) {
+	const checks = getDefProp(schema, "checks");
+	return Array.isArray(checks) && checks.length > 0;
+}
+function unwrapNonEffects(schema) {
+	const type = getDefType(schema);
+	const innerType = getDefProp(schema, "innerType");
+	if ((type === "optional" || type === "nullable" || type === "default") && innerType) return unwrapNonEffects(innerType);
+	return schema;
+}
+var analysisCache = /* @__PURE__ */ new WeakMap();
+function hasRootEffects(schema) {
+	return hasChecks(schema);
+}
+function extractSubSchema(schema, path) {
+	const segments = path.split(".");
+	let currentSchema = schema;
+	let hasEffects = false;
+	for (const segment of segments) {
+		if (!segment) continue;
+		if (hasChecks(currentSchema)) hasEffects = true;
+		const unwrapped = unwrapNonEffects(currentSchema);
+		if (hasChecks(unwrapped)) hasEffects = true;
+		if (isZodObject(unwrapped)) {
+			const shape = getDefProp(unwrapped, "shape");
+			if (!shape || !(segment in shape)) return null;
+			currentSchema = shape[segment];
+		} else if (isZodArray(unwrapped) && /^\d+$/.test(segment)) {
+			const element = getDefProp(unwrapped, "element");
+			if (!element) return null;
+			currentSchema = element;
+		} else return null;
+	}
+	const finalUnwrapped = unwrapNonEffects(currentSchema);
+	const finalChecks = getDefProp(finalUnwrapped, "checks");
+	if (finalChecks) {
+		for (const check of finalChecks) if (check && typeof check === "object" && "type" in check && check.type === "custom") {
+			hasEffects = true;
+			break;
+		}
+	}
+	return {
+		schema: finalUnwrapped,
+		hasEffects
+	};
+}
+function analyzeSchemaPath(schema, path) {
+	let cache = analysisCache.get(schema);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		analysisCache.set(schema, cache);
+	}
+	const cached = cache.get(path);
+	if (cached) return cached;
+	if (hasRootEffects(schema)) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "root-checks"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	const extracted = extractSubSchema(schema, path);
+	if (!extracted) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "invalid-path"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	if (extracted.hasEffects) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "path-checks"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	const result = {
+		canPartialValidate: true,
+		subSchema: extracted.schema
+	};
+	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 setValidating(ctx, fieldPath, isValidating) {
-	if (isValidating) ctx.validatingFields.value = {
-		...ctx.validatingFields.value,
-		[fieldPath]: true
-	};
-	else {
-		const newValidating = { ...ctx.validatingFields.value };
-		delete newValidating[fieldPath];
-		ctx.validatingFields.value = newValidating;
-	}
+	const newSet = new Set(ctx.validatingFields.value);
+	if (isValidating) newSet.add(fieldPath);
+	else newSet.delete(fieldPath);
+	ctx.validatingFields.value = newSet;
 }
 function groupErrorsByPath(issues) {
 	const grouped = /* @__PURE__ */ new Map();
@@ -355,6 +493,18 @@ function createValidation(ctx) {
 		if (!ctx.options.shouldUseNativeValidation) return;
 		for (const [path] of ctx.fieldRefs) applyNativeValidation(path, null);
 	}
+	function scheduleErrorsBatch(errors) {
+		if ((ctx.options.delayError || 0) <= 0) {
+			const newErrors = { ...ctx.errors.value };
+			for (const [fieldPath, error] of errors) {
+				set(newErrors, fieldPath, error);
+				applyNativeValidation(fieldPath, typeof error === "string" ? error : error.message);
+			}
+			ctx.errors.value = newErrors;
+			return;
+		}
+		for (const [fieldPath, error] of errors) scheduleError(fieldPath, error);
+	}
 	function scheduleError(fieldPath, error) {
 		const delayMs = ctx.options.delayError || 0;
 		const errorMessage = typeof error === "string" ? error : error.message;
@@ -396,42 +546,108 @@ function createValidation(ctx) {
 		ctx.errorDelayTimers.clear();
 		ctx.pendingErrors.clear();
 	}
+	async function validateFieldPartial(fieldPath, subSchema, valueHash, 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, {
+					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 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, {
+				hash: valueHash,
+				isValid: false
+			});
+			return false;
+		} finally {
+			setValidating(ctx, fieldPath, false);
+		}
+	}
+	async function validateFieldFull(fieldPath, valueHash, 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, {
+					hash: valueHash,
+					isValid: true
+				});
+				return true;
+			}
+			const fieldErrors = result.error.issues.filter((issue) => {
+				const path = issue.path.join(".");
+				return path === fieldPath || path.startsWith(`${fieldPath}.`);
+			});
+			if (fieldErrors.length === 0) {
+				ctx.errors.value = cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(fieldPath, {
+					hash: valueHash,
+					isValid: true
+				});
+				return true;
+			}
+			ctx.errors.value = 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, {
+				hash: valueHash,
+				isValid: false
+			});
+			return false;
+		} finally {
+			setValidating(ctx, fieldPath, false);
+		}
+	}
 	async function validate(fieldPath) {
 		const generationAtStart = ctx.resetGeneration.value;
 		const criteriaMode = ctx.options.criteriaMode || "firstError";
-		const validatingKey = fieldPath || "_form";
+		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 validatingKey = "_form";
 		setValidating(ctx, validatingKey, true);
 		try {
 			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
 			if (ctx.resetGeneration.value !== generationAtStart) return true;
 			if (result.success) {
-				if (fieldPath) ctx.errors.value = cancelError(fieldPath);
-				else {
-					clearAllPendingErrors();
-					ctx.errors.value = {};
-					clearAllNativeValidation();
-				}
+				clearAllPendingErrors();
+				ctx.errors.value = {};
+				clearAllNativeValidation();
+				ctx.validationCache.clear();
 				return true;
 			}
-			const zodErrors = result.error.issues;
-			if (fieldPath) {
-				const fieldErrors = zodErrors.filter((issue) => {
-					const path = issue.path.join(".");
-					return path === fieldPath || path.startsWith(`${fieldPath}.`);
-				});
-				if (fieldErrors.length === 0) {
-					ctx.errors.value = cancelError(fieldPath);
-					return true;
-				}
-				ctx.errors.value = cancelError(fieldPath);
-				const grouped$1 = groupErrorsByPath(fieldErrors);
-				for (const [path, errors] of grouped$1) scheduleError(path, createFieldError(errors, criteriaMode));
-				return false;
-			}
 			clearAllPendingErrors();
 			ctx.errors.value = {};
-			const grouped = groupErrorsByPath(zodErrors);
-			for (const [path, errors] of grouped) scheduleError(path, createFieldError(errors, criteriaMode));
+			const grouped = groupErrorsByPath(result.error.issues);
+			const errorBatch = [];
+			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
+			scheduleErrorsBatch(errorBatch);
+			ctx.validationCache.clear();
 			return false;
 		} finally {
 			setValidating(ctx, validatingKey, false);
@@ -442,6 +658,48 @@ 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--;
+}
+function clearFieldTouched(touchedFields, touchedFieldCount, fieldName) {
+	if (!(fieldName in touchedFields.value)) return;
+	const newTouched = { ...touchedFields.value };
+	delete newTouched[fieldName];
+	touchedFields.value = newTouched;
+	touchedFieldCount.value--;
+}
+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;
+}
 var validationRequestCounter = 0;
 function createFieldRegistration(ctx, validate) {
 	function register(name, registerOptions) {
@@ -483,16 +741,30 @@ function createFieldRegistration(ctx, validate) {
 				const target = e.target;
 				const value = target.type === "checkbox" ? target.checked : target.value;
 				set(ctx.formData, name, value);
-				ctx.dirtyFields.value = {
-					...ctx.dirtyFields.value,
-					[name]: true
-				};
+				markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+				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") {
-					await validate(name);
-					const fieldOpts$1 = ctx.fieldOptions.get(name);
-					if (fieldOpts$1?.deps && fieldOpts$1.deps.length > 0) for (const depField of fieldOpts$1.deps) validate(depField);
+					const validationDebounceMs = ctx.options.validationDebounce || 0;
+					if (validationDebounceMs > 0) {
+						const existingTimer = ctx.schemaValidationTimers.get(name);
+						if (existingTimer) clearTimeout(existingTimer);
+						const timer = setTimeout(async () => {
+							ctx.schemaValidationTimers.delete(name);
+							await validate(name);
+							if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+								const uniqueDeps = [...new Set(fieldOpts.deps)];
+								await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+							}
+						}, validationDebounceMs);
+						ctx.schemaValidationTimers.set(name, timer);
+					} else {
+						await validate(name);
+						if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+							const uniqueDeps = [...new Set(fieldOpts.deps)];
+							await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+						}
+					}
 				}
-				const fieldOpts = ctx.fieldOptions.get(name);
 				if (fieldOpts?.validate && !fieldOpts.disabled) {
 					const requestId = ++validationRequestCounter;
 					ctx.validationRequestIds.set(name, requestId);
@@ -501,23 +773,24 @@ function createFieldRegistration(ctx, validate) {
 					if (debounceMs > 0) {
 						const existingTimer = ctx.debounceTimers.get(name);
 						if (existingTimer) clearTimeout(existingTimer);
-						const timer = setTimeout(() => {
+						const timer = setTimeout(async () => {
 							ctx.debounceTimers.delete(name);
-							runCustomValidation(name, value, requestId, resetGenAtStart);
+							await runCustomValidation(name, value, requestId, resetGenAtStart);
+							ctx.validationRequestIds.delete(name);
 						}, debounceMs);
 						ctx.debounceTimers.set(name, timer);
 					} else await runCustomValidation(name, value, requestId, resetGenAtStart);
 				}
 			};
 			const onBlur = async (_e) => {
-				ctx.touchedFields.value = {
-					...ctx.touchedFields.value,
-					[name]: true
-				};
+				markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
 				if (ctx.options.mode === "onBlur" || ctx.options.mode === "onTouched" || ctx.submitCount.value > 0 && ctx.options.reValidateMode === "onBlur") {
 					await validate(name);
 					const fieldOpts = ctx.fieldOptions.get(name);
-					if (fieldOpts?.deps && fieldOpts.deps.length > 0) for (const depField of fieldOpts.deps) validate(depField);
+					if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+						const uniqueDeps = [...new Set(fieldOpts.deps)];
+						await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+					}
 				}
 			};
 			const refCallback = (el) => {
@@ -539,18 +812,17 @@ function createFieldRegistration(ctx, validate) {
 						clearTimeout(timer);
 						ctx.debounceTimers.delete(name);
 					}
+					const schemaTimer = ctx.schemaValidationTimers.get(name);
+					if (schemaTimer) {
+						clearTimeout(schemaTimer);
+						ctx.schemaValidationTimers.delete(name);
+					}
 					ctx.validationRequestIds.delete(name);
 					if (opts?.shouldUnregister ?? ctx.options.shouldUnregister ?? false) {
 						unset(ctx.formData, name);
-						const newErrors = { ...ctx.errors.value };
-						delete newErrors[name];
-						ctx.errors.value = newErrors;
-						const newTouched = { ...ctx.touchedFields.value };
-						delete newTouched[name];
-						ctx.touchedFields.value = newTouched;
-						const newDirty = { ...ctx.dirtyFields.value };
-						delete newDirty[name];
-						ctx.dirtyFields.value = newDirty;
+						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);
@@ -574,10 +846,7 @@ function createFieldRegistration(ctx, validate) {
 				get: () => get(ctx.formData, name),
 				set: (val) => {
 					set(ctx.formData, name, val);
-					ctx.dirtyFields.value = {
-						...ctx.dirtyFields.value,
-						[name]: true
-					};
+					markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 				}
 			}) }
 		};
@@ -585,21 +854,9 @@ function createFieldRegistration(ctx, validate) {
 	function unregister(name, options) {
 		const opts = options || {};
 		if (!opts.keepValue) unset(ctx.formData, name);
-		if (!opts.keepError) {
-			const newErrors = { ...ctx.errors.value };
-			delete newErrors[name];
-			ctx.errors.value = newErrors;
-		}
-		if (!opts.keepTouched) {
-			const newTouched = { ...ctx.touchedFields.value };
-			delete newTouched[name];
-			ctx.touchedFields.value = newTouched;
-		}
-		if (!opts.keepDirty) {
-			const newDirty = { ...ctx.dirtyFields.value };
-			delete newDirty[name];
-			ctx.dirtyFields.value = newDirty;
-		}
+		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);
 		ctx.fieldRefs.delete(name);
 		ctx.fieldOptions.delete(name);
 		ctx.fieldHandlers.delete(name);
@@ -608,6 +865,11 @@ function createFieldRegistration(ctx, validate) {
 			clearTimeout(timer);
 			ctx.debounceTimers.delete(name);
 		}
+		const schemaTimer = ctx.schemaValidationTimers.get(name);
+		if (schemaTimer) {
+			clearTimeout(schemaTimer);
+			ctx.schemaValidationTimers.delete(name);
+		}
 		ctx.validationRequestIds.delete(name);
 	}
 	return {
@@ -644,6 +906,35 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				indexCache.set(item.key, idx);
 			});
 		};
+		const appendToCache = (startIndex) => {
+			const items = fa.items.value;
+			for (let i = startIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
+		const updateCacheAfterInsert = (insertIndex, _insertCount) => {
+			const items = fa.items.value;
+			for (let i = insertIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
+		const swapInCache = (indexA, indexB) => {
+			const items = fa.items.value;
+			const itemA = items[indexA];
+			const itemB = items[indexB];
+			if (itemA) indexCache.set(itemA.key, indexA);
+			if (itemB) indexCache.set(itemB.key, indexB);
+		};
+		const updateCacheAfterRemove = (removedKey, startIndex) => {
+			indexCache.delete(removedKey);
+			const items = fa.items.value;
+			for (let i = startIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
 		const createItem = (key) => ({
 			key,
 			get index() {
@@ -686,11 +977,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...fa.items.value, ...newItems];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			appendToCache(insertIndex);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(insertIndex, values.length, focusOptions);
 			return true;
@@ -711,11 +999,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...newItems, ...fa.items.value];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			updateCacheAfterInsert(0, values.length);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(0, values.length, focusOptions);
 			return true;
@@ -729,10 +1014,7 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const newValues = [...currentValues];
 			newValues[index] = value;
 			set(ctx.formData, name, newValues);
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -754,11 +1036,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, newValues);
 			const keyToRemove = fa.items.value[index]?.key;
 			fa.items.value = fa.items.value.filter((item) => item.key !== keyToRemove);
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			if (keyToRemove) updateCacheAfterRemove(keyToRemove, index);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -787,11 +1066,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				...newItems,
 				...fa.items.value.slice(clampedIndex)
 			];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			updateCacheAfterInsert(clampedIndex, values.length);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(clampedIndex, values.length, focusOptions);
 			return true;
@@ -812,12 +1088,9 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				newItems[indexA] = itemB;
 				newItems[indexB] = itemA;
 				fa.items.value = newItems;
-				rebuildIndexCache();
+				swapInCache(indexA, indexB);
 			}
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -840,12 +1113,15 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				const clampedTo = Math.min(to, newItems.length);
 				newItems.splice(clampedTo, 0, removedItem);
 				fa.items.value = newItems;
-				rebuildIndexCache();
+				const minIdx = Math.min(from, clampedTo);
+				const maxIdx = Math.max(from, clampedTo);
+				const items = fa.items.value;
+				for (let i = minIdx; i <= maxIdx; i++) {
+					const item = items[i];
+					if (item) indexCache.set(item.key, i);
+				}
 			}
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -854,10 +1130,7 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, newValues);
 			fa.items.value = newValues.map(() => createItem(generateId()));
 			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -872,11 +1145,8 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			}
 			set(ctx.formData, name, []);
 			fa.items.value = [];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			indexCache.clear();
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -895,14 +1165,15 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			}
 			const sortedIndices = [...new Set(validIndices)].sort((a, b) => b - a);
 			const indicesToRemove = new Set(sortedIndices);
+			const keysToRemove = fa.items.value.filter((_, i) => indicesToRemove.has(i)).map((item) => item.key);
 			const newValues = currentValues.filter((_, i) => !indicesToRemove.has(i));
 			set(ctx.formData, name, newValues);
 			fa.items.value = fa.items.value.filter((_, i) => !indicesToRemove.has(i));
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			for (const key of keysToRemove) indexCache.delete(key);
+			fa.items.value.forEach((item, idx) => {
+				indexCache.set(item.key, idx);
+			});
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -934,33 +1205,6 @@ function updateDomElement(el, value) {
 	if (el.type === "checkbox") el.checked = value;
 	else el.value = value;
 }
-function markFieldDirty(dirtyFields, fieldName) {
-	dirtyFields.value = {
-		...dirtyFields.value,
-		[fieldName]: true
-	};
-}
-function markFieldTouched(touchedFields, fieldName) {
-	touchedFields.value = {
-		...touchedFields.value,
-		[fieldName]: true
-	};
-}
-function clearFieldDirty(dirtyFields, fieldName) {
-	const newDirty = { ...dirtyFields.value };
-	delete newDirty[fieldName];
-	dirtyFields.value = newDirty;
-}
-function clearFieldTouched(touchedFields, fieldName) {
-	const newTouched = { ...touchedFields.value };
-	delete newTouched[fieldName];
-	touchedFields.value = newTouched;
-}
-function clearFieldErrors(errors, fieldName) {
-	const newErrors = { ...errors.value };
-	for (const key of Object.keys(newErrors)) if (key === fieldName || key.startsWith(`${fieldName}.`)) delete newErrors[key];
-	errors.value = newErrors;
-}
 function useForm(options) {
 	const ctx = createFormContext(options);
 	const { validate, clearAllPendingErrors } = createValidation(ctx);
@@ -984,32 +1228,84 @@ function useForm(options) {
 	}
 	const setFocusWrapper = (name) => setFocus(name);
 	const { fields } = createFieldArrayManager(ctx, validate, setFocusWrapper);
+	let lastSyncTime = 0;
+	const SYNC_DEBOUNCE_MS = 16;
+	function syncWithDebounce() {
+		const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+		if (now - lastSyncTime < SYNC_DEBOUNCE_MS) return;
+		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+		lastSyncTime = now;
+	}
+	let lastErrors = ctx.errors.value;
+	let lastExternalErrors = ctx.externalErrors.value;
+	let cachedMergedErrors = null;
 	function getMergedErrors() {
-		return {
+		if (cachedMergedErrors !== null && lastErrors === ctx.errors.value && lastExternalErrors === ctx.externalErrors.value) return cachedMergedErrors;
+		lastErrors = ctx.errors.value;
+		lastExternalErrors = ctx.externalErrors.value;
+		cachedMergedErrors = {
 			...ctx.errors.value,
 			...ctx.externalErrors.value
 		};
+		return cachedMergedErrors;
 	}
-	const formState = (0, vue.computed)(() => {
-		const mergedErrors = getMergedErrors();
-		return {
-			errors: mergedErrors,
-			isDirty: Object.keys(ctx.dirtyFields.value).some((k) => ctx.dirtyFields.value[k]),
-			dirtyFields: ctx.dirtyFields.value,
-			isValid: (ctx.submitCount.value > 0 || Object.keys(ctx.touchedFields.value).length > 0) && Object.keys(mergedErrors).length === 0,
-			isSubmitting: ctx.isSubmitting.value,
-			isLoading: ctx.isLoading.value,
-			isReady: !ctx.isLoading.value,
-			isValidating: Object.keys(ctx.validatingFields.value).some((k) => ctx.validatingFields.value[k]),
-			validatingFields: ctx.validatingFields.value,
-			touchedFields: ctx.touchedFields.value,
-			submitCount: ctx.submitCount.value,
-			defaultValuesError: ctx.defaultValuesError.value,
-			isSubmitted: ctx.submitCount.value > 0,
-			isSubmitSuccessful: ctx.isSubmitSuccessful.value,
-			disabled: ctx.isDisabled.value
-		};
+	const isDirtyComputed = (0, vue.computed)(() => ctx.dirtyFieldCount.value > 0);
+	const errorsComputed = (0, vue.computed)(() => getMergedErrors());
+	const isValidComputed = (0, vue.computed)(() => {
+		if (!(ctx.submitCount.value > 0 || ctx.touchedFieldCount.value > 0)) return false;
+		return Object.keys(errorsComputed.value).length === 0;
 	});
+	const isReadyComputed = (0, vue.computed)(() => !ctx.isLoading.value);
+	const isValidatingComputed = (0, vue.computed)(() => ctx.validatingFields.value.size > 0);
+	const isSubmittedComputed = (0, vue.computed)(() => ctx.submitCount.value > 0);
+	const formStateInternal = (0, vue.reactive)({
+		get errors() {
+			return errorsComputed.value;
+		},
+		get isDirty() {
+			return isDirtyComputed.value;
+		},
+		get dirtyFields() {
+			return ctx.dirtyFields.value;
+		},
+		get isValid() {
+			return isValidComputed.value;
+		},
+		get isSubmitting() {
+			return ctx.isSubmitting.value;
+		},
+		get isLoading() {
+			return ctx.isLoading.value;
+		},
+		get isReady() {
+			return isReadyComputed.value;
+		},
+		get isValidating() {
+			return isValidatingComputed.value;
+		},
+		get validatingFields() {
+			return ctx.validatingFields.value;
+		},
+		get touchedFields() {
+			return ctx.touchedFields.value;
+		},
+		get submitCount() {
+			return ctx.submitCount.value;
+		},
+		get defaultValuesError() {
+			return ctx.defaultValuesError.value;
+		},
+		get isSubmitted() {
+			return isSubmittedComputed.value;
+		},
+		get isSubmitSuccessful() {
+			return ctx.isSubmitSuccessful.value;
+		},
+		get disabled() {
+			return ctx.isDisabled.value;
+		}
+	});
+	const formState = (0, vue.computed)(() => formStateInternal);
 	function handleSubmit(onValid, onInvalid) {
 		return async (e) => {
 			e.preventDefault();
@@ -1019,7 +1315,7 @@ function useForm(options) {
 			ctx.submitCount.value++;
 			ctx.isSubmitSuccessful.value = false;
 			try {
-				syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+				syncWithDebounce();
 				if (await validate()) {
 					await onValid(ctx.formData);
 					ctx.isSubmitSuccessful.value = true;
@@ -1045,8 +1341,8 @@ function useForm(options) {
 			}
 		}
 		set(ctx.formData, name, value);
-		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, name);
-		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, name);
+		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
 		if (!ctx.fieldOptions.get(name)?.controlled) {
 			const fieldRef = ctx.fieldRefs.get(name);
 			if (fieldRef?.value) updateDomElement(fieldRef.value, value);
@@ -1057,15 +1353,23 @@ function useForm(options) {
 		const opts = resetOptions || {};
 		ctx.resetGeneration.value++;
 		clearAllPendingErrors();
-		ctx.validatingFields.value = {};
+		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);
 		Object.keys(ctx.formData).forEach((key) => delete ctx.formData[key]);
-		const sourceValues = values || ctx.defaultValues;
-		const newValues = JSON.parse(JSON.stringify(sourceValues));
+		const newValues = deepClone(values || ctx.defaultValues);
 		Object.assign(ctx.formData, newValues);
 		if (!opts.keepErrors) ctx.errors.value = {};
-		if (!opts.keepTouched) ctx.touchedFields.value = {};
-		if (!opts.keepDirty) ctx.dirtyFields.value = {};
+		if (!opts.keepTouched) {
+			ctx.touchedFields.value = {};
+			ctx.touchedFieldCount.value = 0;
+		}
+		if (!opts.keepDirty) {
+			ctx.dirtyFields.value = {};
+			ctx.dirtyFieldCount.value = 0;
+		}
 		if (!opts.keepSubmitCount) ctx.submitCount.value = 0;
 		if (!opts.keepIsSubmitting) ctx.isSubmitting.value = false;
 		if (!opts.keepIsSubmitSuccessful) ctx.isSubmitSuccessful.value = false;
@@ -1099,11 +1403,11 @@ function useForm(options) {
 		let defaultValue = opts.defaultValue;
 		if (defaultValue === void 0) defaultValue = get(ctx.defaultValues, name);
 		else set(ctx.defaultValues, name, defaultValue);
-		const clonedValue = defaultValue !== void 0 ? JSON.parse(JSON.stringify(defaultValue)) : void 0;
+		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, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
+		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, 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 : ""));
@@ -1193,7 +1497,7 @@ function useForm(options) {
 				}
 			}
 		}
-		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+		syncWithDebounce();
 		if (nameOrNames === void 0) return { ...ctx.formData };
 		if (Array.isArray(nameOrNames)) {
 			const result = {};