@vuehookform/core 0.2.11 → 0.3.3

package/dist/vuehookform.cjs

@@ -53,6 +53,153 @@ function generateId() {
 	const random = Math.random().toString(36).substring(2, 11);
 	return `field_${Date.now()}_${idCounter++}_${random}`;
 }
+var proc = globalThis.process;
+const __DEV__ = proc?.env?.NODE_ENV !== "production";
+var warnedMessages = /* @__PURE__ */ new Set();
+function warnOnce(message, key) {
+	if (!__DEV__) return;
+	const cacheKey = key ?? message;
+	if (warnedMessages.has(cacheKey)) return;
+	warnedMessages.add(cacheKey);
+	console.warn(`[vue-hook-form] ${message}`);
+}
+function warn(message) {
+	if (!__DEV__) return;
+	console.warn(`[vue-hook-form] ${message}`);
+}
+function validatePathSyntax(path) {
+	if (!__DEV__) return null;
+	if (!path || path.trim() === "") return "Path cannot be empty";
+	if (path.startsWith(".") || path.endsWith(".") || path.includes("..")) return `Invalid path "${path}": contains empty segments`;
+	if (path.includes("[")) return `Invalid path "${path}": use dot notation (e.g., "items.0") instead of bracket notation (e.g., "items[0]")`;
+	if (/\s/.test(path)) return `Invalid path "${path}": paths cannot contain whitespace`;
+	return null;
+}
+function traverseSchemaPath(schema, path) {
+	const segments = path.split(".");
+	let currentSchema = schema;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (!segment) continue;
+		currentSchema = unwrapSchema(currentSchema);
+		if (isZodObject(currentSchema)) {
+			const shape = currentSchema.shape;
+			if (segment in shape) {
+				const nextSchema = shape[segment];
+				if (nextSchema) {
+					currentSchema = nextSchema;
+					continue;
+				}
+			}
+			return {
+				error: `Field "${segments.slice(0, i + 1).join(".")}" does not exist in schema`,
+				availableFields: Object.keys(shape),
+				segmentIndex: i
+			};
+		}
+		if (isZodArray(currentSchema) && /^\d+$/.test(segment)) {
+			currentSchema = currentSchema.element;
+			continue;
+		}
+		return {
+			error: `Cannot navigate path "${path}" at segment "${segment}"`,
+			segmentIndex: i
+		};
+	}
+	return { schema: currentSchema };
+}
+function validatePathAgainstSchema(schema, path) {
+	if (!__DEV__) return { valid: true };
+	try {
+		const result = traverseSchemaPath(schema, path);
+		if ("error" in result) return {
+			valid: false,
+			reason: result.error,
+			availableFields: result.availableFields
+		};
+		return { valid: true };
+	} catch {
+		return { valid: true };
+	}
+}
+function isArrayFieldInSchema(schema, path) {
+	if (!__DEV__) return null;
+	try {
+		const result = traverseSchemaPath(schema, path);
+		if ("error" in result) return null;
+		return isZodArray(unwrapSchema(result.schema));
+	} catch {
+		return null;
+	}
+}
+function warnInvalidPath(fnName, path, reason) {
+	if (!__DEV__) return;
+	let message = `${fnName}("${path}"): ${reason}`;
+	if (reason.includes("bracket notation")) {
+		const fixedPath = path.replace(/\[(\d+)\]/g, ".$1");
+		message += `\n  FIX: Use dot notation for array indices`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	} else if (reason.includes("empty")) {
+		message += `\n  FIX: Provide a non-empty field path`;
+		message += `\n  EXAMPLE: ${fnName}("email") or ${fnName}("user.address.city")`;
+	} else if (reason.includes("whitespace")) {
+		const fixedPath = path.replace(/\s/g, "");
+		message += `\n  FIX: Remove spaces from the field path`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	} else if (reason.includes("empty segments")) {
+		const fixedPath = path.replace(/\.{2,}/g, ".").replace(/^\./, "").replace(/\.$/, "");
+		message += `\n  FIX: Remove extra dots from the path`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	}
+	warnOnce(message, `invalid-path:${fnName}:${path}`);
+}
+function warnPathNotInSchema(fnName, path, availableFields) {
+	if (!__DEV__) return;
+	let message = `${fnName}("${path}"): Path does not exist in your Zod schema.`;
+	message += `\n  FIX: Check that the path matches your schema definition exactly (case-sensitive)`;
+	if (availableFields && availableFields.length > 0) {
+		const pathLower = path.toLowerCase();
+		const suggestions = availableFields.filter((f) => f.toLowerCase().includes(pathLower) || pathLower.includes(f.toLowerCase()));
+		if (suggestions.length > 0) message += `\n  DID YOU MEAN: ${suggestions.slice(0, 3).map((s) => `"${s}"`).join(", ")}`;
+		message += `\n  AVAILABLE: ${availableFields.slice(0, 8).join(", ")}${availableFields.length > 8 ? "..." : ""}`;
+	}
+	warnOnce(message, `path-not-in-schema:${fnName}:${path}`);
+}
+function warnFieldsOnNonArray(path) {
+	if (!__DEV__) return;
+	warnOnce(`fields("${path}"): Expected an array field, but this path does not point to an array in your schema. The fields() method is only for array fields. Use register() for non-array fields.`, `fields-non-array:${path}`);
+}
+function warnArrayOperationRejected(operation, path, reason, details) {
+	if (!__DEV__) return;
+	warn(`${operation}() on "${path}": ${{
+		maxLength: details ? `Would exceed maxLength (current: ${details.current}, max: ${details.limit})` : "Would exceed maxLength rule",
+		minLength: details ? `Would violate minLength (current: ${details.current}, min: ${details.limit})` : "Would violate minLength rule"
+	}[reason]}. Operation was silently ignored.`);
+}
+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) {
+	return schema.def[prop];
+}
+function getTypeName(schema) {
+	return getDefProp(schema, "typeName");
+}
+function isZodObject(schema) {
+	return getTypeName(schema) === "ZodObject";
+}
+function isZodArray(schema) {
+	return getTypeName(schema) === "ZodArray";
+}
+function unwrapSchema(schema) {
+	const typeName = getTypeName(schema);
+	const innerType = getDefProp(schema, "innerType");
+	const schemaType = getDefProp(schema, "schema");
+	if ((typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodDefault") && innerType) return unwrapSchema(innerType);
+	if (typeName === "ZodEffects" && schemaType) return unwrapSchema(schemaType);
+	return schema;
+}
 function createFormContext(options) {
 	const formData = (0, vue.reactive)({});
 	const defaultValues = (0, vue.reactive)({});
@@ -92,6 +239,13 @@ function createFormContext(options) {
 	const debounceTimers = /* @__PURE__ */ new Map();
 	const validationRequestIds = /* @__PURE__ */ new Map();
 	const resetGeneration = (0, vue.ref)(0);
+	const isDisabled = (0, vue.ref)(false);
+	if (options.disabled !== void 0) {
+		isDisabled.value = (0, vue.toValue)(options.disabled) ?? false;
+		(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) {
@@ -141,6 +295,7 @@ function createFormContext(options) {
 		debounceTimers,
 		validationRequestIds,
 		resetGeneration,
+		isDisabled,
 		options
 	};
 }
@@ -191,12 +346,23 @@ function createFieldError(errors, criteriaMode = "firstError") {
 	};
 }
 function createValidation(ctx) {
+	function applyNativeValidation(fieldPath, errorMessage) {
+		if (!ctx.options.shouldUseNativeValidation) return;
+		const el = ctx.fieldRefs.get(fieldPath)?.value;
+		if (el && "setCustomValidity" in el) el.setCustomValidity(errorMessage || "");
+	}
+	function clearAllNativeValidation() {
+		if (!ctx.options.shouldUseNativeValidation) return;
+		for (const [path] of ctx.fieldRefs) applyNativeValidation(path, null);
+	}
 	function scheduleError(fieldPath, error) {
 		const delayMs = ctx.options.delayError || 0;
+		const errorMessage = typeof error === "string" ? error : error.message;
 		if (delayMs <= 0) {
 			const newErrors = { ...ctx.errors.value };
 			set(newErrors, fieldPath, error);
 			ctx.errors.value = newErrors;
+			applyNativeValidation(fieldPath, errorMessage);
 			return;
 		}
 		const existingTimer = ctx.errorDelayTimers.get(fieldPath);
@@ -210,6 +376,7 @@ function createValidation(ctx) {
 				const newErrors = { ...ctx.errors.value };
 				set(newErrors, fieldPath, pendingError);
 				ctx.errors.value = newErrors;
+				applyNativeValidation(fieldPath, errorMessage);
 			}
 		}, delayMs);
 		ctx.errorDelayTimers.set(fieldPath, timer);
@@ -221,6 +388,7 @@ function createValidation(ctx) {
 			ctx.errorDelayTimers.delete(fieldPath);
 		}
 		ctx.pendingErrors.delete(fieldPath);
+		applyNativeValidation(fieldPath, null);
 		return clearFieldErrors$1(ctx.errors.value, fieldPath);
 	}
 	function clearAllPendingErrors() {
@@ -241,6 +409,7 @@ function createValidation(ctx) {
 				else {
 					clearAllPendingErrors();
 					ctx.errors.value = {};
+					clearAllNativeValidation();
 				}
 				return true;
 			}
@@ -276,6 +445,12 @@ function createValidation(ctx) {
 var validationRequestCounter = 0;
 function createFieldRegistration(ctx, validate) {
 	function register(name, registerOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("register", name, syntaxError);
+			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+			if (!schemaResult.valid) warnPathNotInSchema("register", name, schemaResult.availableFields);
+		}
 		let fieldRef = ctx.fieldRefs.get(name);
 		if (!fieldRef) {
 			fieldRef = (0, vue.ref)(null);
@@ -394,6 +569,7 @@ function createFieldRegistration(ctx, validate) {
 			ref: handlers.refCallback,
 			onInput: handlers.onInput,
 			onBlur: handlers.onBlur,
+			...ctx.isDisabled.value && { disabled: true },
 			...registerOptions?.controlled && { value: (0, vue.computed)({
 				get: () => get(ctx.formData, name),
 				set: (val) => {
@@ -441,6 +617,13 @@ function createFieldRegistration(ctx, validate) {
 }
 function createFieldArrayManager(ctx, validate, setFocus) {
 	function fields(name, options) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("fields", name, syntaxError);
+			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+			if (!schemaResult.valid) warnPathNotInSchema("fields", name, schemaResult.availableFields);
+			if (isArrayFieldInSchema(ctx.options.schema, name) === false) warnFieldsOnNonArray(name);
+		}
 		let fieldArray = ctx.fieldArrays.get(name);
 		if (!fieldArray) {
 			const existingValues = get(ctx.formData, name) || [];
@@ -488,11 +671,17 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 		};
 		const append = (value, focusOptions) => {
 			const values = normalizeToArray(value);
-			if (values.length === 0) return;
+			if (values.length === 0) return true;
 			const currentValues = get(ctx.formData, name) || [];
 			const insertIndex = currentValues.length;
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("append", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const newValues = [...currentValues, ...values];
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
@@ -504,13 +693,20 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			};
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(insertIndex, values.length, focusOptions);
+			return true;
 		};
 		const prepend = (value, focusOptions) => {
 			const values = normalizeToArray(value);
-			if (values.length === 0) return;
+			if (values.length === 0) return true;
 			const currentValues = get(ctx.formData, name) || [];
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("prepend", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const newValues = [...values, ...currentValues];
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
@@ -522,10 +718,14 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			};
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(0, values.length, focusOptions);
+			return true;
 		};
 		const update = (index, value) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (index < 0 || index >= currentValues.length) return;
+			if (index < 0 || index >= currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("update", name, index, currentValues.length);
+				return false;
+			}
 			const newValues = [...currentValues];
 			newValues[index] = value;
 			set(ctx.formData, name, newValues);
@@ -534,12 +734,22 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				[name]: true
 			};
 			if (ctx.options.mode === "onChange") validate(name);
+			return true;
 		};
 		const removeAt = (index) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (index < 0 || index >= currentValues.length) return;
+			if (index < 0 || index >= currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("remove", name, index, currentValues.length);
+				return false;
+			}
 			const rules = fa.rules;
-			if (rules?.minLength && currentValues.length - 1 < rules.minLength.value) return;
+			if (rules?.minLength && currentValues.length - 1 < rules.minLength.value) {
+				if (__DEV__) warnArrayOperationRejected("remove", name, "minLength", {
+					current: currentValues.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
 			const newValues = currentValues.filter((_, i) => i !== index);
 			set(ctx.formData, name, newValues);
 			const keyToRemove = fa.items.value[index]?.key;
@@ -550,13 +760,20 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				[name]: true
 			};
 			if (ctx.options.mode === "onChange") validate(name);
+			return true;
 		};
 		const insert = (index, value, focusOptions) => {
 			const values = normalizeToArray(value);
-			if (values.length === 0) return;
+			if (values.length === 0) return true;
 			const currentValues = get(ctx.formData, name) || [];
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("insert", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const clampedIndex = Math.max(0, Math.min(index, currentValues.length));
 			const newValues = [
 				...currentValues.slice(0, clampedIndex),
@@ -577,10 +794,14 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			};
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(clampedIndex, values.length, focusOptions);
+			return true;
 		};
 		const swap = (indexA, indexB) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (indexA < 0 || indexB < 0 || indexA >= currentValues.length || indexB >= currentValues.length) return;
+			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;
+			}
 			const newValues = [...currentValues];
 			[newValues[indexA], newValues[indexB]] = [newValues[indexB], newValues[indexA]];
 			set(ctx.formData, name, newValues);
@@ -598,10 +819,14 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				[name]: true
 			};
 			if (ctx.options.mode === "onChange") validate(name);
+			return true;
 		};
 		const move = (from, to) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (from < 0 || from >= currentValues.length || to < 0) return;
+			if (from < 0 || from >= currentValues.length || to < 0) {
+				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) {
@@ -622,9 +847,10 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				[name]: true
 			};
 			if (ctx.options.mode === "onChange") validate(name);
+			return true;
 		};
 		const replace = (newValues) => {
-			if (!Array.isArray(newValues)) return;
+			if (!Array.isArray(newValues)) return false;
 			set(ctx.formData, name, newValues);
 			fa.items.value = newValues.map(() => createItem(generateId()));
 			rebuildIndexCache();
@@ -633,12 +859,60 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				[name]: true
 			};
 			if (ctx.options.mode === "onChange") validate(name);
+			return true;
+		};
+		const removeAll = () => {
+			const rules = fa.rules;
+			if (rules?.minLength && rules.minLength.value > 0) {
+				if (__DEV__) warnArrayOperationRejected("removeAll", name, "minLength", {
+					current: fa.items.value.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
+			set(ctx.formData, name, []);
+			fa.items.value = [];
+			rebuildIndexCache();
+			ctx.dirtyFields.value = {
+				...ctx.dirtyFields.value,
+				[name]: true
+			};
+			if (ctx.options.mode === "onChange") validate(name);
+			return true;
+		};
+		const removeMany = (indices) => {
+			const currentValues = get(ctx.formData, name) || [];
+			const validIndices = indices.filter((i) => i >= 0 && i < currentValues.length);
+			if (validIndices.length === 0) return true;
+			const rules = fa.rules;
+			const remainingCount = currentValues.length - validIndices.length;
+			if (rules?.minLength && remainingCount < rules.minLength.value) {
+				if (__DEV__) warnArrayOperationRejected("removeMany", name, "minLength", {
+					current: currentValues.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
+			const sortedIndices = [...new Set(validIndices)].sort((a, b) => b - a);
+			const indicesToRemove = new Set(sortedIndices);
+			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
+			};
+			if (ctx.options.mode === "onChange") validate(name);
+			return true;
 		};
 		return {
 			value: fa.items.value,
 			append,
 			prepend,
 			remove: removeAt,
+			removeAll,
+			removeMany,
 			insert,
 			swap,
 			move,
@@ -692,6 +966,14 @@ function useForm(options) {
 	const { validate, clearAllPendingErrors } = createValidation(ctx);
 	const { register, unregister } = createFieldRegistration(ctx, validate);
 	function setFocus(name, focusOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("setFocus", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("setFocus", name, schemaResult.availableFields);
+			}
+		}
 		const fieldRef = ctx.fieldRefs.get(name);
 		if (!fieldRef?.value) return;
 		const el = fieldRef.value;
@@ -702,11 +984,14 @@ function useForm(options) {
 	}
 	const setFocusWrapper = (name) => setFocus(name);
 	const { fields } = createFieldArrayManager(ctx, validate, setFocusWrapper);
-	const formState = (0, vue.computed)(() => {
-		const mergedErrors = {
+	function getMergedErrors() {
+		return {
 			...ctx.errors.value,
 			...ctx.externalErrors.value
 		};
+	}
+	const formState = (0, vue.computed)(() => {
+		const mergedErrors = getMergedErrors();
 		return {
 			errors: mergedErrors,
 			isDirty: Object.keys(ctx.dirtyFields.value).some((k) => ctx.dirtyFields.value[k]),
@@ -721,12 +1006,14 @@ function useForm(options) {
 			submitCount: ctx.submitCount.value,
 			defaultValuesError: ctx.defaultValuesError.value,
 			isSubmitted: ctx.submitCount.value > 0,
-			isSubmitSuccessful: ctx.isSubmitSuccessful.value
+			isSubmitSuccessful: ctx.isSubmitSuccessful.value,
+			disabled: ctx.isDisabled.value
 		};
 	});
 	function handleSubmit(onValid, onInvalid) {
 		return async (e) => {
 			e.preventDefault();
+			if (ctx.isDisabled.value) return;
 			if (ctx.isSubmitting.value) return;
 			ctx.isSubmitting.value = true;
 			ctx.submitCount.value++;
@@ -749,6 +1036,14 @@ function useForm(options) {
 		};
 	}
 	function setValue(name, value, setValueOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("setValue", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("setValue", name, schemaResult.availableFields);
+			}
+		}
 		set(ctx.formData, name, value);
 		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, name);
 		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, name);
@@ -758,9 +1053,6 @@ function useForm(options) {
 		}
 		if (setValueOptions?.shouldValidate) validate(name);
 	}
-	function getValue(name) {
-		return get(ctx.formData, name);
-	}
 	function reset(values, resetOptions) {
 		const opts = resetOptions || {};
 		ctx.resetGeneration.value++;
@@ -788,6 +1080,14 @@ function useForm(options) {
 		}
 	}
 	function resetField(name, resetFieldOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("resetField", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("resetField", name, schemaResult.availableFields);
+			}
+		}
 		const opts = resetFieldOptions || {};
 		ctx.resetGeneration.value++;
 		const errorTimer = ctx.errorDelayTimers.get(name);
@@ -810,6 +1110,17 @@ function useForm(options) {
 		}
 	}
 	function watch$1(name) {
+		if (__DEV__ && name) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("watch", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("watch", n, schemaResult.availableFields);
+				}
+			}
+		}
 		return (0, vue.computed)(() => {
 			if (!name) return ctx.formData;
 			if (Array.isArray(name)) {
@@ -821,6 +1132,18 @@ function useForm(options) {
 		});
 	}
 	function clearErrors(name) {
+		if (__DEV__ && name && !String(name).startsWith("root")) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				if (String(n).startsWith("root")) continue;
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("clearErrors", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("clearErrors", n, schemaResult.availableFields);
+				}
+			}
+		}
 		if (name === void 0) {
 			ctx.errors.value = {};
 			return;
@@ -836,7 +1159,40 @@ function useForm(options) {
 		} : error.message);
 		ctx.errors.value = newErrors;
 	}
+	function setErrors(errors, options$1) {
+		const newErrors = options$1?.shouldReplace ? {} : { ...ctx.errors.value };
+		for (const [name, error] of Object.entries(errors)) {
+			if (error === void 0) continue;
+			set(newErrors, name, typeof error === "string" ? error : error.type ? {
+				type: error.type,
+				message: error.message
+			} : error.message);
+		}
+		ctx.errors.value = newErrors;
+	}
+	function hasErrors(fieldPath) {
+		const mergedErrors = getMergedErrors();
+		if (fieldPath === void 0) return Object.keys(mergedErrors).length > 0;
+		const error = get(mergedErrors, fieldPath);
+		return error !== void 0 && error !== null;
+	}
+	function getErrors(fieldPath) {
+		const mergedErrors = getMergedErrors();
+		if (fieldPath === void 0) return mergedErrors;
+		return get(mergedErrors, fieldPath);
+	}
 	function getValues(nameOrNames) {
+		if (__DEV__ && nameOrNames) {
+			const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("getValues", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("getValues", n, schemaResult.availableFields);
+				}
+			}
+		}
 		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
 		if (nameOrNames === void 0) return { ...ctx.formData };
 		if (Array.isArray(nameOrNames)) {
@@ -847,6 +1203,14 @@ function useForm(options) {
 		return get(ctx.formData, nameOrNames);
 	}
 	function getFieldState(name) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("getFieldState", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("getFieldState", name, schemaResult.availableFields);
+			}
+		}
 		const error = get(ctx.errors.value, name);
 		return {
 			isDirty: ctx.dirtyFields.value[name] === true,
@@ -856,6 +1220,17 @@ function useForm(options) {
 		};
 	}
 	async function trigger(name) {
+		if (__DEV__ && name) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("trigger", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("trigger", n, schemaResult.availableFields);
+				}
+			}
+		}
 		if (name === void 0) return await validate();
 		if (Array.isArray(name)) {
 			let allValid = true;
@@ -871,13 +1246,15 @@ function useForm(options) {
 		formState,
 		fields,
 		setValue,
-		getValue,
 		reset,
 		resetField,
 		watch: watch$1,
 		validate,
 		clearErrors,
 		setError,
+		setErrors,
+		hasErrors,
+		getErrors,
 		getValues,
 		getFieldState,
 		trigger,
@@ -910,10 +1287,10 @@ function useController(options) {
 	const { name, control, defaultValue } = options;
 	const form = control ?? useFormContext();
 	const elementRef = (0, vue.ref)(null);
-	if (defaultValue !== void 0 && form.getValue(name) === void 0) form.setValue(name, defaultValue);
+	if (defaultValue !== void 0 && form.getValues(name) === void 0) form.setValue(name, defaultValue);
 	const value = (0, vue.computed)({
 		get: () => {
-			return form.getValue(name) ?? defaultValue;
+			return form.getValues(name) ?? defaultValue;
 		},
 		set: (newValue) => {
 			form.setValue(name, newValue);