@vuehookform/core 0.3.3 → 0.4.0

package/dist/core/fieldState.d.ts

@@ -1,34 +1,45 @@
-import { ShallowRef } from 'vue';
+import { Ref, ShallowRef } from 'vue';
 /**
- * Mark a field as dirty (value has changed from default)
+ * Mark a field as dirty (value has changed from default).
+ * Optimized to skip clone if already dirty.
+ * Maintains O(1) dirty field count for performance.
  *
  * @param dirtyFields - The reactive dirty fields record
+ * @param dirtyFieldCount - Counter for O(1) isDirty checks
  * @param fieldName - Name of the field to mark as dirty
  */
-export declare function markFieldDirty(dirtyFields: ShallowRef<Record<string, boolean>>, fieldName: string): void;
+export declare function markFieldDirty(dirtyFields: ShallowRef<Record<string, boolean>>, dirtyFieldCount: Ref<number>, fieldName: string): void;
 /**
- * Mark a field as touched (user has interacted with it)
+ * Mark a field as touched (user has interacted with it).
+ * Optimized to skip clone if already touched.
+ * Maintains O(1) touched field count for performance.
  *
  * @param touchedFields - The reactive touched fields record
+ * @param touchedFieldCount - Counter for O(1) touched checks
  * @param fieldName - Name of the field to mark as touched
  */
-export declare function markFieldTouched(touchedFields: ShallowRef<Record<string, boolean>>, fieldName: string): void;
+export declare function markFieldTouched(touchedFields: ShallowRef<Record<string, boolean>>, touchedFieldCount: Ref<number>, fieldName: string): void;
 /**
- * Clear dirty state for a field
+ * Clear dirty state for a field.
+ * Maintains O(1) dirty field count for performance.
  *
  * @param dirtyFields - The reactive dirty fields record
+ * @param dirtyFieldCount - Counter for O(1) isDirty checks
  * @param fieldName - Name of the field to clear
  */
-export declare function clearFieldDirty(dirtyFields: ShallowRef<Record<string, boolean>>, fieldName: string): void;
+export declare function clearFieldDirty(dirtyFields: ShallowRef<Record<string, boolean>>, dirtyFieldCount: Ref<number>, fieldName: string): void;
 /**
- * Clear touched state for a field
+ * Clear touched state for a field.
+ * Maintains O(1) touched field count for performance.
  *
  * @param touchedFields - The reactive touched fields record
+ * @param touchedFieldCount - Counter for O(1) touched checks
  * @param fieldName - Name of the field to clear
  */
-export declare function clearFieldTouched(touchedFields: ShallowRef<Record<string, boolean>>, fieldName: string): void;
+export declare function clearFieldTouched(touchedFields: ShallowRef<Record<string, boolean>>, touchedFieldCount: Ref<number>, fieldName: string): void;
 /**
- * Clear errors for a field and its nested paths
+ * Clear errors for a field and its nested paths.
+ * Optimized with early exit if nothing to delete.
  *
  * @param errors - The reactive errors record
  * @param fieldName - Name of the field (clears exact match and all nested paths)

package/dist/core/formContext.d.ts

@@ -33,7 +33,7 @@ export interface FormContext<FormValues> {
     submitCount: Ref<number>;
     defaultValuesError: Ref<unknown>;
     isSubmitSuccessful: Ref<boolean>;
-    validatingFields: ShallowRef<Record<string, boolean>>;
+    validatingFields: ShallowRef<Set<string>>;
     externalErrors: ShallowRef<FieldErrors<FormValues>>;
     errorDelayTimers: Map<string, ReturnType<typeof setTimeout>>;
     pendingErrors: Map<string, FieldErrorValue>;
@@ -45,6 +45,13 @@ export interface FormContext<FormValues> {
     validationRequestIds: Map<string, number>;
     resetGeneration: Ref<number>;
     isDisabled: Ref<boolean>;
+    dirtyFieldCount: Ref<number>;
+    touchedFieldCount: Ref<number>;
+    validationCache: Map<string, {
+        hash: string;
+        isValid: boolean;
+    }>;
+    schemaValidationTimers: Map<string, ReturnType<typeof setTimeout>>;
     options: UseFormOptions<ZodType>;
 }
 /**

package/dist/types.d.ts

@@ -170,8 +170,8 @@ export interface FormState<T> {
     isReady: boolean;
     /** Whether any field is currently being validated */
     isValidating: boolean;
-    /** Record of fields currently being validated */
-    validatingFields: Record<string, boolean>;
+    /** Set of field paths currently being validated */
+    validatingFields: Set<string>;
     /** Record of touched field paths */
     touchedFields: Record<string, boolean>;
     /** Record of dirty field paths */
@@ -571,6 +571,22 @@ export interface UseFormOptions<TSchema extends ZodType> {
      * ```
      */
     delayError?: number;
+    /**
+     * Debounce time in milliseconds for schema validation in onChange mode.
+     * Prevents excessive validation calls during rapid typing.
+     * Unlike delayError which delays showing errors, this delays the validation itself.
+     *
+     * @example Debounce validation by 150ms
+     * ```ts
+     * useForm({
+     *   schema,
+     *   mode: 'onChange',
+     *   validationDebounce: 150  // Wait 150ms of idle time before validating
+     * })
+     * // Reduces validation calls during rapid typing
+     * ```
+     */
+    validationDebounce?: number;
     /**
      * External values to sync to form. Changes update formData without marking dirty.
      * Useful for server-fetched data or parent component state.

package/dist/utils/clone.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Deep clone utility for form values.
+ * Handles common types without JSON.parse/stringify overhead.
+ *
+ * Properly handles:
+ * - Primitives (pass-through)
+ * - Plain objects (recursive clone)
+ * - Arrays (recursive clone)
+ * - Date objects (new Date instance)
+ * - null/undefined (pass-through)
+ *
+ * Does NOT handle (by design, not needed for form data):
+ * - Circular references
+ * - Map/Set/WeakMap/WeakSet
+ * - Functions
+ * - Symbols
+ * - Class instances (cloned as plain objects)
+ */
+export declare function deepClone<T>(obj: T): T;

package/dist/utils/hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fast value hashing for validation cache.
+ * Uses JSON.stringify for objects/arrays, direct conversion for primitives.
+ * Returns a string that can be compared for equality.
+ */
+export declare function hashValue(value: unknown): string;

package/dist/utils/paths.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Clear the path cache. Useful for testing or when paths change significantly.
+ * @internal
+ */
+export declare function clearPathCache(): void;
 /**
  * Get value from object using dot notation path
  * @example get({ user: { name: 'John' } }, 'user.name') => 'John'

package/dist/utils/schemaExtract.d.ts

@@ -0,0 +1,42 @@
+import { ZodType } from 'zod';
+interface SchemaPathAnalysis {
+    canPartialValidate: boolean;
+    subSchema?: ZodType;
+    reason?: 'root-checks' | 'path-checks' | 'unsupported-type' | 'invalid-path';
+}
+/**
+ * Check if the root schema has refinements/checks
+ * Root-level checks may depend on multiple fields, requiring full validation
+ */
+export declare function hasRootEffects(schema: ZodType): boolean;
+/**
+ * Extract sub-schema for a given path
+ *
+ * Returns the sub-schema and whether any checks/refinements were encountered.
+ * If checks are found at object level, partial validation isn't safe because
+ * the refinement may depend on other fields.
+ *
+ * @param schema - Root form schema
+ * @param path - Dot-notation field path (e.g., "user.address.city")
+ * @returns Sub-schema and effects flag, or null if path invalid
+ */
+export declare function extractSubSchema(schema: ZodType, path: string): {
+    schema: ZodType;
+    hasEffects: boolean;
+} | null;
+/**
+ * Analyze if a path can be validated in isolation
+ *
+ * This is the main entry point for determining partial validation eligibility.
+ * Results are cached per-schema for performance.
+ *
+ * @param schema - Root form schema
+ * @param path - Dot-notation field path
+ * @returns Analysis result with eligibility and reason
+ */
+export declare function analyzeSchemaPath(schema: ZodType, path: string): SchemaPathAnalysis;
+/**
+ * Clear the analysis cache (useful for testing)
+ */
+export declare function clearAnalysisCache(): void;
+export {};