mobx-formly 0.0.3 → 0.1.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { Form } from './form.js';
+export { BaseForm } from './form.js';
+export type { Form } from './form.js';
 export { createForm } from './create-form.js';
 export type { InferredFormValues } from './create-form.js';
-export type { FieldError, FieldErrors, FieldPath, FieldPathValue, FieldState, FieldStateTree, FieldValues, FormOptions, FormSchema, SafeParseFormSchema, SchemaIssue, SchemaOutput, SchemaResult, ValibotFormSchema, ValibotRunResult, RegisterOptions, RegisterReturn, ResetOptions, SetValueConfig, SubmitHandlers, } from './types.js';
+export type { ErrorNamespacePath, FieldError, FieldErrors, FieldPath, FieldPathValue, FieldState, FieldStateTree, FieldValues, FieldValidate, FormOptions, FormSchema, GlobalErrors, ResetFieldOptions, SafeParseFormSchema, SchemaIssue, SchemaOutput, SchemaResult, StandardFormSchema, StandardSchemaIssue, StandardSchemaResult, ValibotFormSchema, ValibotRunResult, ValidateResult, Resolver, ResolverOptions, ResolverResult, RegisterOptions, RegisterReturn, ResetOptions, SetErrorConfig, SetValueConfig, SubmitHandlers, TriggerConfig, } from './types.js';

package/dist/index.js

@@ -1,2 +1,2 @@
-export { Form } from './form.js';
+export { BaseForm } from './form.js';
 export { createForm } from './create-form.js';

package/dist/path-store.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Path-indexed observable store with lazy nested proxies.
+ *
+ * Values are stored flat by dot-separated path while reads go through
+ * stable proxies that expose the same data as a nested tree. A reverse
+ * index of path counts and children sets keeps parent branches alive
+ * while any child path exists.
+ */
+export declare class PathStore<V extends object> {
+    private readonly store;
+    private readonly counts;
+    private readonly children;
+    private readonly proxies;
+    /** Whether a value is stored at the exact path. */
+    has(path: string): boolean;
+    /** Number of stored values. */
+    get size(): number;
+    /** Returns the stored value at the exact path. */
+    get(path: string): V | undefined;
+    /** All stored path and value pairs. */
+    entries(): Array<[string, V]>;
+    /** All stored paths. */
+    paths(): string[];
+    /** Stores a value and registers its path in the reverse index. */
+    set(path: string, value: V): void;
+    /** Removes a value and prunes empty parent branches of the index. */
+    delete(path: string): void;
+    /** Removes all values and index data. */
+    clear(): void;
+    /** Returns the stored value or creates, stores, and returns it. */
+    ensure(path: string, create: () => V): V;
+    /** Returns the stable read-only nested view of the stored values. */
+    proxy(): object;
+    private createProxy;
+    /** Drops cached proxies for the removed path and its children so churn does not accumulate. */
+    private evictProxies;
+    private addPathToIndex;
+}

package/dist/path-store.js

@@ -0,0 +1,134 @@
+import { observable } from 'mobx';
+/**
+ * Path-indexed observable store with lazy nested proxies.
+ *
+ * Values are stored flat by dot-separated path while reads go through
+ * stable proxies that expose the same data as a nested tree. A reverse
+ * index of path counts and children sets keeps parent branches alive
+ * while any child path exists.
+ */
+export class PathStore {
+    store = observable.map();
+    counts = observable.map();
+    children = observable.map({}, { deep: false });
+    proxies = new Map();
+    /** Whether a value is stored at the exact path. */
+    has(path) { return this.store.has(path); }
+    /** Number of stored values. */
+    get size() { return this.store.size; }
+    /** Returns the stored value at the exact path. */
+    get(path) { return this.store.get(path); }
+    /** All stored path and value pairs. */
+    entries() { return [...this.store.entries()]; }
+    /** All stored paths. */
+    paths() { return [...this.store.keys()]; }
+    /** Stores a value and registers its path in the reverse index. */
+    set(path, value) {
+        if (!this.store.has(path))
+            this.addPathToIndex(path);
+        this.store.set(path, value);
+    }
+    /** Removes a value and prunes empty parent branches of the index. */
+    delete(path) {
+        if (!this.store.delete(path))
+            return;
+        this.evictProxies(path);
+        const parts = path.split('.');
+        for (let index = parts.length; index > 0; index -= 1) {
+            const current = parts.slice(0, index).join('.');
+            const count = (this.counts.get(current) ?? 1) - 1;
+            if (count > 0) {
+                this.counts.set(current, count);
+                continue;
+            }
+            this.counts.delete(current);
+            const parent = parts.slice(0, index - 1).join('.');
+            const siblings = this.children.get(parent);
+            siblings?.delete(parts[index - 1]);
+            if (siblings?.size === 0) {
+                this.children.delete(parent);
+                if (parent)
+                    this.proxies.delete(parent);
+            }
+        }
+    }
+    /** Removes all values and index data. */
+    clear() {
+        this.store.clear();
+        this.counts.clear();
+        this.children.clear();
+        // The root proxy stays cached so public getters keep a stable identity across clearErrors and reset.
+        const root = this.proxies.get('');
+        this.proxies.clear();
+        if (root)
+            this.proxies.set('', root);
+    }
+    /** Returns the stored value or creates, stores, and returns it. */
+    ensure(path, create) {
+        const existing = this.store.get(path);
+        if (existing)
+            return existing;
+        this.set(path, create());
+        return this.store.get(path);
+    }
+    /** Returns the stable read-only nested view of the stored values. */
+    proxy() {
+        return this.createProxy('');
+    }
+    createProxy(path) {
+        const cached = this.proxies.get(path);
+        if (cached)
+            return cached;
+        const proxy = new Proxy({}, {
+            get: (_, property) => {
+                if (typeof property !== 'string')
+                    return undefined;
+                const current = this.store.get(path);
+                if (current && property in current)
+                    return current[property];
+                const childPath = path ? `${path}.${property}` : property;
+                const value = this.store.get(childPath);
+                if (value && !this.children.has(childPath))
+                    return value;
+                return this.counts.has(childPath) ? this.createProxy(childPath) : undefined;
+            },
+            ownKeys: () => [...Object.keys(this.store.get(path) ?? {}), ...(this.children.get(path) ?? [])],
+            getOwnPropertyDescriptor: (_, property) => {
+                if (typeof property !== 'string')
+                    return undefined;
+                const value = this.store.get(path);
+                if (value && property in value)
+                    return { configurable: true, enumerable: true, value: value[property] };
+                return this.children.get(path)?.has(property) ? { configurable: true, enumerable: true } : undefined;
+            },
+            set: () => false,
+            deleteProperty: () => false,
+        });
+        this.proxies.set(path, proxy);
+        return proxy;
+    }
+    /** Drops cached proxies for the removed path and its children so churn does not accumulate. */
+    evictProxies(path) {
+        if (path)
+            this.proxies.delete(path);
+        const prefix = `${path}.`;
+        for (const key of this.proxies.keys()) {
+            if (key.startsWith(prefix))
+                this.proxies.delete(key);
+        }
+    }
+    addPathToIndex(path) {
+        const parts = path.split('.');
+        for (let index = 1; index <= parts.length; index += 1) {
+            const current = parts.slice(0, index).join('.');
+            this.counts.set(current, (this.counts.get(current) ?? 0) + 1);
+            const parent = parts.slice(0, index - 1).join('.');
+            let siblings = this.children.get(parent);
+            if (!siblings) {
+                siblings = observable.set();
+                this.children.set(parent, siblings);
+            }
+            siblings.add(parts[index - 1]);
+        }
+    }
+}

package/dist/types.d.ts

@@ -8,6 +8,28 @@ export interface SchemaIssue {
     }>;
     message: string;
 }
+export interface StandardSchemaIssue {
+    message: string;
+    path?: readonly (PropertyKey | {
+        readonly key: PropertyKey;
+    } | {
+        readonly toString: () => string;
+    })[];
+}
+export type StandardSchemaResult<T> = {
+    value: T;
+    issues?: undefined;
+} | {
+    value?: never;
+    issues: readonly StandardSchemaIssue[];
+};
+export interface StandardFormSchema<T> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<T> | Promise<StandardSchemaResult<T>>;
+    };
+}
 export type SchemaResult<T> = {
     success: true;
     data: T;
@@ -34,25 +56,36 @@ export interface ValibotRunResult<T> {
     issues?: SchemaIssue[];
 }
 /** Schema contract accepted by Form. Both Zod and Valibot schemas fit this interface. */
-export type FormSchema<T> = SafeParseFormSchema<T> | ValibotFormSchema<T>;
-export type SchemaOutput<S> = S extends SafeParseFormSchema<infer T> ? T : S extends {
+export type FormSchema<T> = SafeParseFormSchema<T> | ValibotFormSchema<T> | StandardFormSchema<T>;
+export type SchemaOutput<S> = S extends SafeParseFormSchema<infer T> ? T : S extends StandardFormSchema<infer T> ? T : S extends {
     readonly '~types'?: {
         readonly output: infer T;
     };
 } ? T : never;
 /** Dot-separated path into the form value tree, for example `user.email`. */
 export type FieldPath<T = FieldValues> = 'root' | {
-    [K in Extract<keyof T, string>]: T[K] extends readonly unknown[] ? T[K] extends readonly (infer I)[] ? I extends object ? K | `${K}.${number}` | `${K}.${number}.${FieldPath<I>}` : K | `${K}.${number}` : K : T[K] extends object ? K | `${K}.${FieldPath<T[K]>}` : K;
+    [K in Extract<keyof T, string>]: FieldPathForValue<K, T[K]>;
 }[Extract<keyof T, string>];
-export type FieldPathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? FieldPathValue<T[K], Rest> : T extends readonly (infer I)[] ? FieldPathValue<I, Rest> : never : P extends keyof T ? T[P] : T extends readonly (infer I)[] ? P extends `${number}` ? I : never : never;
+type FieldPathForValue<K extends string, V> = V extends readonly (infer I)[] ? I extends object ? K | `${K}.${number}` | `${K}.${number}.${FieldPath<I>}` : K | `${K}.${number}` : V extends ReadonlyMap<infer MapKey, infer MapValue> ? MapKey extends string ? MapValue extends object ? K | `${K}.${MapKey}` | `${K}.${MapKey}.${FieldPath<MapValue>}` : K | `${K}.${MapKey}` : K : V extends Date | RegExp | ReadonlySet<unknown> ? K : V extends object ? K | `${K}.${FieldPath<V>}` : K;
+export type FieldPathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? FieldPathValue<T[K], Rest> : T extends readonly (infer I)[] ? FieldPathValue<I, Rest> : T extends ReadonlyMap<infer MapKey, infer MapValue> ? K extends MapKey ? FieldPathValue<MapValue, Rest> : never : never : P extends keyof T ? T[P] : T extends readonly (infer I)[] ? P extends `${number}` ? I : never : T extends ReadonlyMap<infer MapKey, infer MapValue> ? P extends MapKey ? MapValue : never : never;
 export interface FieldError {
     type: string;
     message?: string;
+    types?: Record<string, string | true | string[]>;
 }
+/** Result of a single field validator: pass, one message, or several messages. */
+export type ValidateResult = boolean | string | string[] | undefined;
+/** Checks a field value against the rest of the form values. */
+export type FieldValidate<TValue = unknown, TValues extends FieldValues = FieldValues> = (value: TValue, values: TValues) => ValidateResult | Promise<ValidateResult>;
+export type ErrorNamespacePath = 'root' | `root.${string}`;
+export type GlobalErrors = FieldError & Record<string, FieldError | undefined>;
+type FieldErrorTree<V> = V extends readonly (infer I)[] ? FieldError & Array<I extends object ? FieldErrors<I> : FieldError | undefined> : V extends ReadonlyMap<infer MapKey, infer MapValue> ? FieldError & (MapKey extends string ? {
+    [K in MapKey]?: FieldErrorTree<MapValue>;
+} : {}) : V extends Date | RegExp | ReadonlySet<unknown> ? FieldError : V extends object ? FieldError & FieldErrors<V> : FieldError;
 export type FieldErrors<T extends object = FieldValues> = {
-    [K in keyof T]?: T[K] extends readonly (infer I)[] ? FieldError & Array<I extends object ? FieldErrors<I> : FieldError | undefined> : T[K] extends object ? FieldError & FieldErrors<T[K]> : FieldError;
+    [K in keyof T]?: FieldErrorTree<T[K]>;
 } & {
-    root?: FieldError;
+    root?: GlobalErrors;
 };
 export interface FieldState {
     invalid: boolean;
@@ -61,8 +94,11 @@ export interface FieldState {
     isValidating: boolean;
     error?: FieldError;
 }
+type FieldStateValueTree<V> = V extends readonly (infer I)[] ? FieldState & Array<I extends object ? FieldStateTree<I> : FieldState | undefined> : V extends ReadonlyMap<infer MapKey, infer MapValue> ? FieldState & (MapKey extends string ? {
+    [K in MapKey]?: FieldStateValueTree<MapValue>;
+} : {}) : V extends Date | RegExp | ReadonlySet<unknown> ? FieldState : V extends object ? FieldState & FieldStateTree<V> : FieldState;
 export type FieldStateTree<T extends object = FieldValues> = {
-    [K in keyof T]?: T[K] extends readonly (infer I)[] ? FieldState & Array<I extends object ? FieldStateTree<I> : FieldState | undefined> : T[K] extends object ? FieldState & FieldStateTree<T[K]> : FieldState;
+    [K in keyof T]?: FieldStateValueTree<T[K]>;
 } & {
     root?: FieldState;
 };
@@ -72,6 +108,7 @@ export interface FormState<T extends FieldValues = FieldValues> {
     touchedFields: Partial<Record<FieldPath<T>, true>>;
     validatingFields: Partial<Record<FieldPath<T>, true>>;
     isDirty: boolean;
+    isTouched: boolean;
     isValid: boolean;
     isValidating: boolean;
     isSubmitting: boolean;
@@ -102,7 +139,9 @@ export interface RegisterOptions<T extends FieldValues = FieldValues> {
         value: RegExp;
         message?: string;
     };
-    validate?: (value: unknown, values: T) => boolean | string | Promise<boolean | string>;
+    validate?: FieldValidate<unknown, T> | Record<string, FieldValidate<unknown, T>>;
+    /** Field paths re-validated whenever this field changes. */
+    deps?: FieldPath<T> | FieldPath<T>[];
     valueAsNumber?: boolean;
     valueAsDate?: boolean;
     setValueAs?: (value: unknown) => unknown;
@@ -118,23 +157,63 @@ export interface SetValueConfig {
     shouldDirty?: boolean;
     shouldTouch?: boolean;
 }
+export interface SetErrorConfig {
+    shouldFocus?: boolean;
+}
+export interface TriggerConfig {
+    shouldFocus?: boolean;
+    shouldTouch?: boolean;
+}
+export interface ResetFieldOptions<T extends FieldValues, P extends FieldPath<T>> {
+    keepDirty?: boolean;
+    keepTouched?: boolean;
+    keepError?: boolean;
+    defaultValue?: FieldPathValue<T, P>;
+}
 export interface ResetOptions {
     keepDefaultValues?: boolean;
+    keepValues?: boolean;
     keepDirty?: boolean;
+    keepDirtyValues?: boolean;
     keepTouched?: boolean;
     keepErrors?: boolean;
+    keepIsValid?: boolean;
+    keepIsValidating?: boolean;
     keepIsSubmitted?: boolean;
+    keepIsSubmitSuccessful?: boolean;
     keepSubmitCount?: boolean;
 }
 export interface FormOptions<T extends FieldValues> {
     defaultValues?: Partial<T>;
     values?: Partial<T>;
     schema?: FormSchema<T>;
-    mode?: 'onSubmit' | 'onChange' | 'onBlur' | 'all';
+    /** A resolver may submit transformed values, so its output type is not tied to the field values type. */
+    resolver?: Resolver<T, any>;
+    context?: unknown;
+    mode?: 'onSubmit' | 'onChange' | 'onBlur' | 'onTouched' | 'all';
     reValidateMode?: 'onChange' | 'onBlur';
+    criteriaMode?: 'firstError' | 'all';
+    delayError?: number;
+    shouldUseNativeValidation?: boolean;
+    shouldFocusError?: boolean;
     disabled?: boolean;
 }
+export interface ResolverOptions<T extends FieldValues> {
+    criteriaMode?: 'firstError' | 'all';
+    fields: Record<string, RegisterOptions<T>>;
+    names?: FieldPath<T>[];
+    shouldUseNativeValidation?: boolean;
+}
+export type ResolverResult<T extends FieldValues, TTransformedValues = T> = {
+    values: TTransformedValues;
+    errors: Record<string, never>;
+} | {
+    values: Record<string, never>;
+    errors: FieldErrors<T>;
+};
+export type Resolver<T extends FieldValues = FieldValues, TTransformedValues = T> = (values: T, context: unknown, options: ResolverOptions<T>) => ResolverResult<T, TTransformedValues> | Promise<ResolverResult<T, TTransformedValues>>;
 export interface SubmitHandlers<T extends FieldValues> {
     onValid: (values: T, form: unknown) => void | Promise<void>;
     onInvalid?: (errors: FieldErrors<T>, form: unknown) => void | Promise<void>;
 }
+export {};

package/dist/utils.d.ts

@@ -1,6 +1,16 @@
+import type { FieldError, FieldErrors } from './types.js';
 export declare const clone: <T>(value: T) => T;
 export declare const getAtPath: (source: unknown, path: string) => unknown;
 export declare const setAtPath: (target: Record<string, unknown>, path: string, value: unknown) => void;
 export declare const deleteAtPath: (target: Record<string, unknown>, path: string) => void;
+/** Compares form values while preserving Maps, Sets, Dates, and RegExps. */
 export declare const isEqual: (a: unknown, b: unknown) => boolean;
+/** Returns leaf paths whose current values differ from their defaults. */
+export declare const collectDirtyPaths: (values: unknown, defaultValues: unknown) => string[];
+/** Returns leaf paths changed between two value snapshots. */
+export declare const collectChangedPaths: (before: unknown, after: unknown) => string[];
+/** Returns the field error stored at the path in a nested errors object. */
+export declare const findErrorAtPath: (errors: FieldErrors, path: string) => FieldError | undefined;
+/** Collects the flat paths of all field errors in a nested errors object. */
+export declare const collectErrorPaths: (errors: FieldErrors, base?: string) => string[];
 export declare const extractValue: (eventOrValue: unknown) => unknown;

package/dist/utils.js

@@ -1,11 +1,14 @@
+import { isObservableMap, toJS } from 'mobx';
 import { isUnsafeProperty } from 'yummies/data';
 export const clone = (value) => {
     if (typeof structuredClone === 'function') {
         try {
-            return structuredClone(value);
+            // toJS strips MobX proxies so structuredClone can run; it keeps
+            // Dates, Maps, and Sets intact instead of stringifying them.
+            return structuredClone(toJS(value));
         }
         catch {
-            // MobX observable proxies cannot be structured-cloned directly.
+            // Values may still contain non-cloneable data such as functions or DOM nodes.
         }
     }
     return JSON.parse(JSON.stringify(value));
@@ -13,6 +16,8 @@ export const clone = (value) => {
 export const getAtPath = (source, path) => path.split('.').reduce((value, key) => {
     if (isUnsafeProperty(key) || value === null || value === undefined)
         return undefined;
+    if (value instanceof Map || isObservableMap(value))
+        return value.get(key);
     return value[key];
 }, source);
 export const setAtPath = (target, path, value) => {
@@ -21,14 +26,28 @@ export const setAtPath = (target, path, value) => {
     for (const [index, key] of keys.slice(0, -1).entries()) {
         if (isUnsafeProperty(key))
             return;
-        const next = current[key];
         const nextKey = keys[index + 1];
-        if (!next || typeof next !== 'object')
-            current[key] = /^\d+$/.test(nextKey) ? [] : {};
-        current = current[key];
+        const create = () => /^\d+$/.test(nextKey) ? [] : {};
+        if (current instanceof Map || isObservableMap(current)) {
+            let next = current.get(key);
+            if (!next || typeof next !== 'object')
+                current.set(key, next = create());
+            current = next;
+        }
+        else {
+            const record = current;
+            let next = record[key];
+            if (!next || typeof next !== 'object')
+                record[key] = next = create();
+            current = next;
+        }
     }
     const lastKey = keys.at(-1);
-    if (lastKey && !isUnsafeProperty(lastKey))
+    if (!lastKey || isUnsafeProperty(lastKey))
+        return;
+    if (current instanceof Map || isObservableMap(current))
+        current.set(lastKey, value);
+    else
         current[lastKey] = value;
 };
 export const deleteAtPath = (target, path) => {
@@ -39,13 +58,141 @@ export const deleteAtPath = (target, path) => {
     const parent = keys.reduce((value, key) => {
         if (isUnsafeProperty(key) || !value || typeof value !== 'object')
             return undefined;
+        if (value instanceof Map || isObservableMap(value))
+            return value.get(key);
         return value[key];
     }, target);
     if (!parent || typeof parent !== 'object')
         return;
-    delete parent[lastKey];
+    if (parent instanceof Map || isObservableMap(parent))
+        parent.delete(lastKey);
+    else
+        delete parent[lastKey];
+};
+/** Compares form values while preserving Maps, Sets, Dates, and RegExps. */
+export const isEqual = (a, b) => deepEqual(toJS(a), toJS(b), new WeakMap());
+/** Returns leaf paths whose current values differ from their defaults. */
+export const collectDirtyPaths = (values, defaultValues) => {
+    return collectDifferencePaths(values, defaultValues);
+};
+/** Returns leaf paths changed between two value snapshots. */
+export const collectChangedPaths = (before, after) => {
+    return collectDifferencePaths(before, after);
+};
+const collectDifferencePaths = (values, defaultValues) => {
+    const paths = [];
+    const visit = (value, defaultValue, path) => {
+        if (isEqual(value, defaultValue))
+            return;
+        if (value instanceof Map || defaultValue instanceof Map) {
+            if (!(value instanceof Map) || !(defaultValue instanceof Map) || !hasStringKeys(value) || !hasStringKeys(defaultValue)) {
+                if (path)
+                    paths.push(path);
+                return;
+            }
+            const keys = new Set([...value.keys(), ...defaultValue.keys()]);
+            for (const key of keys) {
+                if (!isUnsafeProperty(key))
+                    visit(value.get(key), defaultValue.get(key), path ? `${path}.${key}` : key);
+            }
+            return;
+        }
+        if (Array.isArray(value) || Array.isArray(defaultValue)) {
+            const current = Array.isArray(value) ? value : [];
+            const defaults = Array.isArray(defaultValue) ? defaultValue : [];
+            const length = Math.max(current.length, defaults.length);
+            for (let index = 0; index < length; index += 1)
+                visit(current[index], defaults[index], path ? `${path}.${index}` : String(index));
+            return;
+        }
+        if (isRecord(value) || isRecord(defaultValue)) {
+            const current = isRecord(value) ? value : {};
+            const defaults = isRecord(defaultValue) ? defaultValue : {};
+            const keys = new Set([...Object.keys(current), ...Object.keys(defaults)]);
+            for (const key of keys) {
+                if (!isUnsafeProperty(key))
+                    visit(current[key], defaults[key], path ? `${path}.${key}` : key);
+            }
+            return;
+        }
+        if (isAtomicValue(value) || isAtomicValue(defaultValue)) {
+            if (path)
+                paths.push(path);
+            return;
+        }
+        if (path)
+            paths.push(path);
+    };
+    visit(toJS(values), toJS(defaultValues), '');
+    return paths;
+};
+const isAtomicValue = (value) => value === null || value === undefined || typeof value !== 'object' || value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set;
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value) && !isAtomicValue(value);
+const hasStringKeys = (value) => [...value.keys()].every((key) => typeof key === 'string');
+const deepEqual = (a, b, seen) => {
+    if (Object.is(a, b))
+        return true;
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object')
+        return false;
+    const left = a;
+    const right = b;
+    if (seen.get(left) === right)
+        return true;
+    seen.set(left, right);
+    if (a instanceof Date || b instanceof Date)
+        return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+    if (a instanceof RegExp || b instanceof RegExp)
+        return a instanceof RegExp && b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+    if (a instanceof Map || b instanceof Map) {
+        if (!(a instanceof Map) || !(b instanceof Map) || a.size !== b.size)
+            return false;
+        const unmatched = [...b.entries()];
+        return [...a.entries()].every(([key, value]) => {
+            const index = unmatched.findIndex(([otherKey, otherValue]) => deepEqual(key, otherKey, seen) && deepEqual(value, otherValue, seen));
+            if (index < 0)
+                return false;
+            unmatched.splice(index, 1);
+            return true;
+        });
+    }
+    if (a instanceof Set || b instanceof Set) {
+        if (!(a instanceof Set) || !(b instanceof Set) || a.size !== b.size)
+            return false;
+        const unmatched = [...b];
+        return [...a].every((value) => {
+            const index = unmatched.findIndex((other) => deepEqual(value, other, seen));
+            if (index < 0)
+                return false;
+            unmatched.splice(index, 1);
+            return true;
+        });
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, index) => deepEqual(value, b[index], seen));
+    }
+    const leftKeys = Reflect.ownKeys(a);
+    const rightKeys = Reflect.ownKeys(b);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => (rightKeys.includes(key) && deepEqual(a[key], b[key], seen)));
+};
+/** Returns the field error stored at the path in a nested errors object. */
+export const findErrorAtPath = (errors, path) => {
+    const value = getAtPath(errors, path);
+    return value && typeof value === 'object' && 'type' in value ? value : undefined;
+};
+/** Collects the flat paths of all field errors in a nested errors object. */
+export const collectErrorPaths = (errors, base = '') => {
+    const paths = [];
+    for (const [key, value] of Object.entries(errors)) {
+        if (value === undefined)
+            continue;
+        const path = base ? `${base}.${key}` : key;
+        if (value && typeof value === 'object' && 'type' in value)
+            paths.push(path);
+        if (value && typeof value === 'object')
+            paths.push(...collectErrorPaths(value, path));
+    }
+    return paths;
 };
-export const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 export const extractValue = (eventOrValue) => {
     if (!eventOrValue || typeof eventOrValue !== 'object' || !('target' in eventOrValue))
         return eventOrValue;

package/dist/validation.d.ts

@@ -0,0 +1,52 @@
+import type { Ref } from 'yummies/mobx';
+import type { FieldError, FieldErrors, FieldValues, FormOptions, RegisterOptions } from './types.js';
+/** Form-side collaborators the validator needs, kept as callbacks so Form internals stay private. */
+export interface ValidatorHost<T extends FieldValues> {
+    /** Current form options: schema, resolver, criteriaMode, delayError, and native validation settings. */
+    readonly options: FormOptions<T>;
+    /** Registration options per field path. */
+    readonly fieldOptions: Map<string, RegisterOptions<T>>;
+    /** Registered field refs used for native validity reporting. */
+    readonly refs: Map<string, Ref<HTMLElement | null>>;
+    /** Current value stored at the field path. */
+    valueAt(path: string): unknown;
+    /** Plain copy of the current values for schema and resolver runs. */
+    snapshot(): T;
+    /** Applies a validated error to the form state. */
+    applyError(path: string, error: FieldError | undefined): void;
+}
+/**
+ * Schema, resolver, and rule validation with error delivery for Form.
+ *
+ * Runs Zod-like, Valibot, and Standard Schema contracts or a custom resolver,
+ * checks registration rules with firstError or all criteria modes, relays
+ * messages to native DOM validity, and can delay error display.
+ */
+export declare class FormValidator<T extends FieldValues> {
+    private readonly host;
+    private readonly delayedErrorTimers;
+    private readonly delayedErrors;
+    constructor(host: ValidatorHost<T>);
+    /** Validates values with the resolver or schema and returns nested errors and resolver output. */
+    resolveSchemaErrors(paths?: string[]): Promise<{
+        errors: FieldErrors<T>;
+        values?: T;
+    }>;
+    /** Checks registration rules for one field and returns the failing error if any. */
+    validateRules(path: string): Promise<FieldError | undefined>;
+    /** Groups rule failures into the types map; repeated messages of one rule become arrays. */
+    private collectRuleTypes;
+    /** Combines schema and rule errors for a field according to the criteria mode. */
+    mergeErrors(schemaError: FieldError | undefined, ruleError: FieldError | undefined): FieldError | undefined;
+    /** Delivers a validated error, respecting the delay option and native validity reporting. */
+    applyValidationError(path: string, error: FieldError | undefined): void;
+    /** Applies a pending delayed error immediately, for example on blur. */
+    flushDelayed(path: string): void;
+    /** Drops a pending delayed error without applying it. */
+    cancelDelayed(path: string): void;
+    /** Drops all pending delayed errors without applying them. */
+    cancelAllDelayed(): void;
+    private resolverResultValues;
+    private normalizeSchemaErrors;
+    private applyNativeValidity;
+}