@vuehookform/core 0.4.2 → 0.4.4

package/dist/useController.d.ts

@@ -1,63 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-import { ZodType } from 'zod';
-import { UseFormReturn, Path, PathValue, InferSchema, FieldState } from './types';
-/**
- * Options for useController composable
- */
-export interface UseControllerOptions<TSchema extends ZodType, TPath extends Path<InferSchema<TSchema>>> {
-    /** Field name/path */
-    name: TPath;
-    /** Form control from useForm (uses context if not provided) */
-    control?: UseFormReturn<TSchema>;
-    /** Default value for the field */
-    defaultValue?: PathValue<InferSchema<TSchema>, TPath>;
-}
-/**
- * Field props returned by useController
- */
-export interface ControllerFieldProps<TValue> {
-    /** Current field value */
-    value: Ref<TValue>;
-    /** Field name */
-    name: string;
-    /** Change handler - call with new value */
-    onChange: (value: TValue) => void;
-    /** Blur handler */
-    onBlur: () => void;
-    /** Ref callback for the input element */
-    ref: (el: HTMLElement | null) => void;
-}
-/**
- * Return value from useController
- */
-export interface UseControllerReturn<TValue> {
-    /** Field props for binding to input components */
-    field: ControllerFieldProps<TValue>;
-    /** Current field state (errors, dirty, touched) */
-    fieldState: ComputedRef<FieldState>;
-}
-/**
- * Hook for controlled components that need fine-grained control over field state
- *
- * This composable is useful for integrating with custom input components or
- * third-party UI libraries that don't work with the standard register() approach.
- *
- * @example
- * ```ts
- * // Basic usage with context
- * const { field, fieldState } = useController({ name: 'email' })
- *
- * // With explicit control
- * const { control } = useForm({ schema })
- * const { field, fieldState } = useController({ control, name: 'email' })
- *
- * // In template:
- * // <CustomInput
- * //   :value="field.value.value"
- * //   @update:modelValue="field.onChange"
- * //   @blur="field.onBlur"
- * // />
- * // <span v-if="fieldState.value.error">{{ fieldState.value.error }}</span>
- * ```
- */
-export declare function useController<TSchema extends ZodType, TPath extends Path<InferSchema<TSchema>>>(options: UseControllerOptions<TSchema, TPath>): UseControllerReturn<PathValue<InferSchema<TSchema>, TPath>>;

package/dist/useForm.d.ts

@@ -1,20 +0,0 @@
-import { ZodType } from 'zod';
-import { UseFormOptions, UseFormReturn } from './types';
-/**
- * Main form management composable
- *
- * @example
- * ```ts
- * const schema = z.object({
- *   email: z.email(),
- *   name: z.string().min(2)
- * })
- *
- * const { register, handleSubmit, formState } = useForm({ schema })
- *
- * const onSubmit = (data) => {
- *   console.log(data) // { email: '...', name: '...' }
- * }
- * ```
- */
-export declare function useForm<TSchema extends ZodType>(options: UseFormOptions<TSchema>): UseFormReturn<TSchema>;

package/dist/useFormState.d.ts

@@ -1,39 +0,0 @@
-import { ComputedRef } from 'vue';
-import { ZodType } from 'zod';
-import { UseFormReturn, FormState, InferSchema } from './types';
-/**
- * Keys of FormState that can be subscribed to
- */
-export type FormStateKey = keyof FormState<unknown>;
-/**
- * Options for useFormState composable
- */
-export interface UseFormStateOptions<TSchema extends ZodType> {
-    /** Form control from useForm (uses context if not provided) */
-    control?: UseFormReturn<TSchema>;
-    /** Specific state keys to subscribe to (subscribes to all if not provided) */
-    name?: FormStateKey | FormStateKey[];
-}
-/**
- * Subscribe to specific form state properties
- *
- * This composable allows you to efficiently subscribe to only the form state
- * properties you need, reducing unnecessary re-renders.
- *
- * @example
- * ```ts
- * // Subscribe to all form state
- * const formState = useFormState({})
- *
- * // Subscribe to specific properties
- * const { isSubmitting, errors } = useFormState({ name: ['isSubmitting', 'errors'] })
- *
- * // Subscribe to single property
- * const isDirty = useFormState({ name: 'isDirty' })
- *
- * // With explicit control
- * const { control } = useForm({ schema })
- * const formState = useFormState({ control })
- * ```
- */
-export declare function useFormState<TSchema extends ZodType>(options?: UseFormStateOptions<TSchema>): ComputedRef<Partial<FormState<InferSchema<TSchema>>>>;

package/dist/useWatch.d.ts

@@ -1,46 +0,0 @@
-import { ComputedRef } from 'vue';
-import { ZodType } from 'zod';
-import { UseFormReturn, Path, PathValue, InferSchema } from './types';
-/**
- * Options for useWatch composable
- */
-export interface UseWatchOptions<TSchema extends ZodType, TPath extends Path<InferSchema<TSchema>>> {
-    /** Form control from useForm (uses context if not provided) */
-    control?: UseFormReturn<TSchema>;
-    /** Field path or array of paths to watch (watches all if not provided) */
-    name?: TPath | TPath[];
-    /** Default value when field is undefined */
-    defaultValue?: unknown;
-}
-/**
- * Watch form field values reactively without the full form instance
- *
- * This composable allows you to subscribe to form value changes from any component
- * in the tree, as long as the form context is provided via provideForm().
- *
- * @example
- * ```ts
- * // Watch a single field
- * const email = useWatch({ name: 'email' })
- *
- * // Watch multiple fields
- * const fields = useWatch({ name: ['firstName', 'lastName'] })
- *
- * // Watch all form values
- * const allValues = useWatch({})
- *
- * // With explicit control
- * const { control } = useForm({ schema })
- * const email = useWatch({ control, name: 'email' })
- *
- * // With default value
- * const status = useWatch({ name: 'status', defaultValue: 'pending' })
- * ```
- */
-export declare function useWatch<TSchema extends ZodType>(options?: Omit<UseWatchOptions<TSchema, Path<InferSchema<TSchema>>>, 'name'>): ComputedRef<InferSchema<TSchema>>;
-export declare function useWatch<TSchema extends ZodType, TPath extends Path<InferSchema<TSchema>>>(options: UseWatchOptions<TSchema, TPath> & {
-    name: TPath;
-}): ComputedRef<PathValue<InferSchema<TSchema>, TPath>>;
-export declare function useWatch<TSchema extends ZodType, TPath extends Path<InferSchema<TSchema>>>(options: UseWatchOptions<TSchema, TPath> & {
-    name: TPath[];
-}): ComputedRef<Partial<InferSchema<TSchema>>>;

package/dist/utils/clone.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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)
- * - Circular references (recreates the circular structure in the clone)
- *
- * Does NOT handle (by design, not needed for form data):
- * - Map/Set/WeakMap/WeakSet
- * - Functions
- * - Symbols
- * - Class instances (cloned as plain objects)
- */
-export declare function deepClone<T>(obj: T, seen?: Map<object, unknown>): T;

package/dist/utils/devWarnings.d.ts

@@ -1,55 +0,0 @@
-import { ZodType } from 'zod';
-export declare const __DEV__: boolean;
-/**
- * Warn once per unique message (prevents spam on re-renders)
- */
-export declare function warnOnce(message: string, key?: string): void;
-/**
- * Warn every time (for errors that should always be shown)
- */
-export declare function warn(message: string): void;
-/**
- * Clear warning cache (useful for testing)
- */
-export declare function clearWarningCache(): void;
-/**
- * Validate a dot-notation path string for common syntax errors
- * @returns Error message or null if valid
- */
-export declare function validatePathSyntax(path: string): string | null;
-/**
- * Check if a path exists in a Zod schema
- * This is a runtime check to validate paths against the schema structure
- */
-export declare function validatePathAgainstSchema(schema: ZodType, path: string): {
-    valid: boolean;
-    reason?: string;
-    availableFields?: string[];
-};
-/**
- * Check if a path points to an array field in the schema
- */
-export declare function isArrayFieldInSchema(schema: ZodType, path: string): boolean | null;
-/**
- * Warn about registering an invalid path with fix suggestion
- */
-export declare function warnInvalidPath(fnName: string, path: string, reason: string): void;
-/**
- * Warn about path not in schema with suggestions
- */
-export declare function warnPathNotInSchema(fnName: string, path: string, availableFields?: string[]): void;
-/**
- * Warn about calling fields() on non-array path
- */
-export declare function warnFieldsOnNonArray(path: string): void;
-/**
- * Warn about silent field array operation failures
- */
-export declare function warnArrayOperationRejected(operation: string, path: string, reason: 'maxLength' | 'minLength', details?: {
-    current: number;
-    limit: number;
-}): void;
-/**
- * Warn about array operation with out of bounds index
- */
-export declare function warnArrayIndexOutOfBounds(operation: string, path: string, index: number, length: number): void;

package/dist/utils/hash.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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.
- *
- * Handles circular references by assigning stable IDs via WeakMap,
- * ensuring the same object always produces the same hash.
- */
-export declare function hashValue(value: unknown): string;

package/dist/utils/modeChecks.d.ts

@@ -1,22 +0,0 @@
-import { ValidationMode } from '../types';
-/**
- * Determines if validation should occur on change event.
- * Used by useController and register for consistent mode handling.
- *
- * @param mode - The form's validation mode
- * @param isTouched - Whether the field has been touched
- * @param reValidateMode - The form's reValidateMode (used after first submit)
- * @param hasSubmitted - Whether the form has been submitted at least once (optional, for reValidateMode)
- * @returns true if validation should be triggered
- */
-export declare function shouldValidateOnChange(mode: ValidationMode, isTouched: boolean, reValidateMode?: ValidationMode, hasSubmitted?: boolean): boolean;
-/**
- * Determines if validation should occur on blur event.
- * Used by useController and register for consistent mode handling.
- *
- * @param mode - The form's validation mode
- * @param hasSubmitted - Whether the form has been submitted at least once
- * @param reValidateMode - The form's reValidateMode (used after first submit)
- * @returns true if validation should be triggered
- */
-export declare function shouldValidateOnBlur(mode: ValidationMode, hasSubmitted: boolean, reValidateMode?: ValidationMode): boolean;

package/dist/utils/paths.d.ts

@@ -1,53 +0,0 @@
-/**
- * Clear the path segment cache.
- * Call this between SSR requests to prevent memory accumulation,
- * or in tests to reset state.
- *
- * The cache is bounded to 256 entries, so clearing is optional
- * for client-side only applications.
- */
-export declare function clearPathCache(): void;
-/**
- * Get value from object using dot notation path
- * @example get({ user: { name: 'John' } }, 'user.name') => 'John'
- */
-export declare function get(obj: unknown, path: string): unknown;
-/**
- * Set value in object using dot notation path
- * @example set({}, 'user.name', 'John') => { user: { name: 'John' } }
- */
-export declare function set(obj: Record<string, unknown>, path: string, value: unknown): void;
-/**
- * Delete value from object using dot notation path
- * @example unset({ user: { name: 'John' } }, 'user.name') => { user: {} }
- */
-export declare function unset(obj: Record<string, unknown>, path: string): void;
-/**
- * Check if path exists in object.
- * Unlike `get(obj, path) !== undefined`, this properly distinguishes between
- * a missing path and a path that exists with an `undefined` value.
- *
- * @example
- * has({ name: undefined }, 'name') // true - path exists
- * has({ }, 'name') // false - path doesn't exist
- * has({ user: { name: 'John' } }, 'user.name') // true
- * has({ user: { name: 'John' } }, 'user.age') // false
- */
-export declare function has(obj: Record<string, unknown>, path: string): boolean;
-export declare function generateId(): string;
-/**
- * Check if a path represents an array index
- * @example isArrayPath('users.0') => true
- * @example isArrayPath('users.name') => false
- */
-export declare function isArrayPath(path: string): boolean;
-/**
- * Get parent path
- * @example getParentPath('user.addresses.0.street') => 'user.addresses.0'
- */
-export declare function getParentPath(path: string): string | undefined;
-/**
- * Get field name from path
- * @example getFieldName('user.addresses.0.street') => 'street'
- */
-export declare function getFieldName(path: string): string;

package/dist/utils/schemaExtract.d.ts

@@ -1,42 +0,0 @@
-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 {};