dalila 1.9.13 → 1.9.14

package/dist/form/form-types.d.ts

@@ -2,6 +2,31 @@
  * Type utilities for path-based access
  */
 export type FieldErrors = Record<string, string>;
+export interface SchemaValidationIssue {
+    path?: string;
+    message: string;
+}
+export interface SchemaValidationResult<T = unknown> {
+    value?: T;
+    issues?: SchemaValidationIssue[];
+    formError?: string;
+}
+export interface FormSchemaAdapter<T = unknown> {
+    /**
+     * Validate full form data.
+     */
+    validate(data: unknown): SchemaValidationResult<T> | Promise<SchemaValidationResult<T>>;
+    /**
+     * Optional field-level validation. Useful for validateOn blur/change.
+     */
+    validateField?(path: string, value: unknown, data: unknown): SchemaValidationResult<T> | Promise<SchemaValidationResult<T>>;
+    /**
+     * Optional fallback mapper for unknown schema errors.
+     */
+    mapErrors?(error: unknown): SchemaValidationIssue[] | {
+        formError?: string;
+    };
+}
 export interface FormSubmitContext {
     signal: AbortSignal;
 }
@@ -23,7 +48,14 @@ export interface FormOptions<T> {
     validate?: (data: T) => FieldErrors | {
         fieldErrors?: FieldErrors;
         formError?: string;
-    } | void;
+    } | void | Promise<FieldErrors | {
+        fieldErrors?: FieldErrors;
+        formError?: string;
+    } | void>;
+    /**
+     * Optional schema adapter (zod/valibot/yup/custom).
+     */
+    schema?: FormSchemaAdapter<T>;
     /**
      * When to run validation:
      * - "submit" (default): only on submit
@@ -114,6 +146,11 @@ export interface Form<T> {
      * Create or get a field array
      */
     fieldArray<TItem = unknown>(path: string): FieldArray<TItem>;
+    /**
+     * Watch a specific path and run callback when its value changes.
+     * Returns an idempotent unsubscribe function.
+     */
+    watch(path: string, fn: (next: unknown, prev: unknown) => void): () => void;
 }
 export interface FieldArrayItem<T = unknown> {
     key: string;

package/dist/form/form.js

@@ -275,6 +275,7 @@ export function createForm(options = {}) {
     // Registry
     const fieldRegistry = new Map();
     const fieldArrayRegistry = new Map();
+    const pathWatchers = new Set();
     // Form element reference
     let formElement = null;
     // Submit abort controller
@@ -282,6 +283,94 @@ export function createForm(options = {}) {
     // Default values
     let defaultValues = {};
     let defaultsInitialized = false;
+    function getCurrentSnapshot(preferFieldArrayPaths) {
+        const snapshot = formElement
+            ? (options.parse ?? parseFormData)(formElement, new FormData(formElement))
+            : {};
+        // Field arrays may exist before DOM render; overlay them when DOM snapshot
+        // has no value for that path, or when callers explicitly prefer array state
+        // (useful during reorder mutations before DOM patches apply).
+        for (const [path, array] of fieldArrayRegistry) {
+            const hasDomValue = getNestedValue(snapshot, path) !== undefined;
+            const shouldPreferArrayState = preferFieldArrayPaths?.has(path) === true;
+            if (hasDomValue && !shouldPreferArrayState)
+                continue;
+            const rows = array.fields().map((item) => item.value);
+            setNestedValue(snapshot, path, rows);
+        }
+        return snapshot;
+    }
+    function readPathValue(path, preferFieldArrayPaths) {
+        return getNestedValue(getCurrentSnapshot(preferFieldArrayPaths), path);
+    }
+    function isPathRelated(pathA, pathB) {
+        if (pathA === pathB)
+            return true;
+        if (pathA.startsWith(`${pathB}.`) || pathA.startsWith(`${pathB}[`))
+            return true;
+        if (pathB.startsWith(`${pathA}.`) || pathB.startsWith(`${pathA}[`))
+            return true;
+        return false;
+    }
+    function emitWatchCallback(callback, next, prev) {
+        try {
+            callback(next, prev);
+        }
+        catch (err) {
+            if (typeof console !== 'undefined') {
+                console.error('[Dalila] Error in form.watch callback:', err);
+            }
+        }
+    }
+    function isPlainObject(value) {
+        return Object.prototype.toString.call(value) === '[object Object]';
+    }
+    function areValuesEqual(a, b) {
+        if (Object.is(a, b))
+            return true;
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!areValuesEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        if (isPlainObject(a) && isPlainObject(b)) {
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            for (const key of aKeys) {
+                if (!(key in b))
+                    return false;
+                if (!areValuesEqual(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    function notifyWatchers(changedPath, opts = {}) {
+        if (pathWatchers.size === 0)
+            return;
+        const preferFieldArrayPaths = opts.preferFieldArrayPaths != null
+            ? new Set(opts.preferFieldArrayPaths)
+            : opts.preferFieldArrayPath
+                ? new Set([opts.preferFieldArrayPath])
+                : undefined;
+        for (const watcher of pathWatchers) {
+            if (changedPath && !isPathRelated(changedPath, watcher.path))
+                continue;
+            const next = readPathValue(watcher.path, preferFieldArrayPaths);
+            if (areValuesEqual(next, watcher.lastValue))
+                continue;
+            const prev = watcher.lastValue;
+            watcher.lastValue = next;
+            emitWatchCallback(watcher.callback, next, prev);
+        }
+    }
     // Initialize defaults
     (async () => {
         try {
@@ -317,6 +406,189 @@ export function createForm(options = {}) {
     // Validation mode
     const validateOn = options.validateOn ?? 'submit';
     let hasSubmitted = false;
+    let validationRunSeq = 0;
+    let formValidationRunId = 0;
+    let formInvalidationId = 0;
+    const latestFieldValidationByPath = new Map();
+    function beginValidation(path) {
+        if (path) {
+            // Field-level validation should invalidate pending full-form validations,
+            // but keep other field paths independent.
+            formInvalidationId += 1;
+            const runId = ++validationRunSeq;
+            latestFieldValidationByPath.set(path, runId);
+            return {
+                kind: 'path',
+                path,
+                runId,
+                formRunIdAtStart: formValidationRunId,
+                formInvalidationIdAtStart: formInvalidationId,
+            };
+        }
+        // Full-form validation invalidates previous full-form and field-level runs.
+        formValidationRunId += 1;
+        latestFieldValidationByPath.clear();
+        const runId = ++validationRunSeq;
+        return {
+            kind: 'form',
+            runId,
+            formRunIdAtStart: formValidationRunId,
+            formInvalidationIdAtStart: formInvalidationId,
+        };
+    }
+    function isValidationCurrent(token) {
+        if (token.kind === 'form') {
+            return token.formRunIdAtStart === formValidationRunId &&
+                token.formInvalidationIdAtStart === formInvalidationId;
+        }
+        if (!token.path)
+            return false;
+        return token.formRunIdAtStart === formValidationRunId &&
+            latestFieldValidationByPath.get(token.path) === token.runId;
+    }
+    function isPromiseLike(value) {
+        return !!value && typeof value.then === 'function';
+    }
+    function mergeValidationOutcomes(outcomes) {
+        const mergedFieldErrors = {};
+        let formError = undefined;
+        let value;
+        let hasValue = false;
+        for (const outcome of outcomes) {
+            for (const [path, message] of Object.entries(outcome.fieldErrors)) {
+                if (!(path in mergedFieldErrors)) {
+                    mergedFieldErrors[path] = message;
+                }
+            }
+            if (formError == null && typeof outcome.formError === 'string' && outcome.formError.length > 0) {
+                formError = outcome.formError;
+            }
+            if (outcome.hasValue) {
+                hasValue = true;
+                value = outcome.value;
+            }
+        }
+        return { fieldErrors: mergedFieldErrors, formError, value, hasValue };
+    }
+    function normalizeLegacyValidationResult(result) {
+        if (!result || typeof result !== 'object') {
+            return { fieldErrors: {} };
+        }
+        if ('fieldErrors' in result || 'formError' in result) {
+            const typedResult = result;
+            return {
+                fieldErrors: typedResult.fieldErrors ?? {},
+                formError: typedResult.formError,
+            };
+        }
+        return { fieldErrors: result };
+    }
+    function normalizeSchemaValidationResult(result) {
+        const fieldErrors = {};
+        let formError = result.formError;
+        const hasValue = Object.prototype.hasOwnProperty.call(result, 'value');
+        for (const issue of result.issues ?? []) {
+            if (issue.path && !(issue.path in fieldErrors)) {
+                fieldErrors[issue.path] = issue.message;
+                continue;
+            }
+            if (!issue.path && formError == null) {
+                formError = issue.message;
+            }
+        }
+        return { fieldErrors, formError, value: result.value, hasValue };
+    }
+    function runLegacyValidation(data) {
+        if (!options.validate)
+            return { fieldErrors: {} };
+        const result = options.validate(data);
+        if (isPromiseLike(result)) {
+            return result
+                .then((resolved) => normalizeLegacyValidationResult(resolved))
+                .catch((error) => ({
+                fieldErrors: {},
+                formError: error instanceof Error ? error.message : 'Validation failed',
+            }));
+        }
+        return normalizeLegacyValidationResult(result);
+    }
+    function runSchemaValidation(data, path) {
+        if (!options.schema)
+            return { fieldErrors: {} };
+        const schema = options.schema;
+        const execute = () => {
+            if (path && schema.validateField) {
+                return schema.validateField(path, getNestedValue(data, path), data);
+            }
+            return schema.validate(data);
+        };
+        const normalizeMappedError = (error) => {
+            const mapped = schema.mapErrors?.(error);
+            if (Array.isArray(mapped)) {
+                if (mapped.length === 0) {
+                    return {
+                        fieldErrors: {},
+                        formError: error instanceof Error ? error.message : 'Schema validation failed',
+                    };
+                }
+                return normalizeSchemaValidationResult({ issues: mapped });
+            }
+            if (mapped && typeof mapped === 'object') {
+                const mappedFormError = mapped.formError;
+                if (typeof mappedFormError === 'string' && mappedFormError.length > 0) {
+                    return {
+                        fieldErrors: {},
+                        formError: mappedFormError,
+                    };
+                }
+                return {
+                    fieldErrors: {},
+                    formError: error instanceof Error ? error.message : 'Schema validation failed',
+                };
+            }
+            return {
+                fieldErrors: {},
+                formError: error instanceof Error ? error.message : 'Schema validation failed',
+            };
+        };
+        try {
+            const result = execute();
+            if (isPromiseLike(result)) {
+                return result
+                    .then((resolved) => normalizeSchemaValidationResult(resolved))
+                    .catch((error) => normalizeMappedError(error));
+            }
+            return normalizeSchemaValidationResult(result);
+        }
+        catch (error) {
+            return normalizeMappedError(error);
+        }
+    }
+    function applyValidationOutcome(outcome, path) {
+        if (path && options.schema?.validateField) {
+            errors.update((prev) => {
+                const next = {};
+                for (const [key, message] of Object.entries(prev)) {
+                    if (!isPathRelated(key, path)) {
+                        next[key] = message;
+                    }
+                }
+                for (const [key, message] of Object.entries(outcome.fieldErrors)) {
+                    if (isPathRelated(key, path)) {
+                        next[key] = message;
+                    }
+                }
+                return next;
+            });
+            formErrorSignal.set(outcome.formError ?? null);
+        }
+        else {
+            errors.set(outcome.fieldErrors);
+            formErrorSignal.set(outcome.formError ?? null);
+        }
+        return Object.keys(outcome.fieldErrors).length === 0 &&
+            !(typeof outcome.formError === 'string' && outcome.formError.length > 0);
+    }
     // Error Management
     function setError(path, message) {
         errors.update((prev) => ({ ...prev, [path]: message }));
@@ -346,6 +618,26 @@ export function createForm(options = {}) {
     function formError() {
         return formErrorSignal();
     }
+    function watch(path, fn) {
+        const watcher = {
+            path,
+            callback: fn,
+            lastValue: readPathValue(path),
+        };
+        pathWatchers.add(watcher);
+        let active = true;
+        const unsubscribe = () => {
+            if (!active)
+                return;
+            active = false;
+            pathWatchers.delete(watcher);
+        };
+        const ownerScope = getCurrentScope();
+        if (ownerScope) {
+            ownerScope.onCleanup(unsubscribe);
+        }
+        return unsubscribe;
+    }
     // Touched / Dirty Management
     function touched(path) {
         return touchedSet().has(path);
@@ -372,38 +664,53 @@ export function createForm(options = {}) {
             return next;
         });
     }
-    // Validation
-    function validate(data) {
-        if (!options.validate)
-            return true;
-        clearErrors();
-        const result = options.validate(data);
-        if (!result)
-            return true;
-        // Check if result is object with fieldErrors/formError
-        if (typeof result === 'object' && result !== null) {
-            if ('fieldErrors' in result || 'formError' in result) {
-                const typedResult = result;
-                if (typedResult.fieldErrors) {
-                    errors.set(typedResult.fieldErrors);
-                }
-                if (typedResult.formError) {
-                    formErrorSignal.set(typedResult.formError);
-                }
-                // Check if fieldErrors is empty (not just truthy)
-                // Validator can return { fieldErrors: {}, formError: null } which is valid
-                const hasFieldErrors = typedResult.fieldErrors && Object.keys(typedResult.fieldErrors).length > 0;
-                const hasFormError = typedResult.formError && typedResult.formError.length > 0;
-                return !hasFieldErrors && !hasFormError;
+    function resolveValidationOutcome(data, opts = {}) {
+        if (!options.schema && !options.validate) {
+            return { fieldErrors: {}, value: data, hasValue: true };
+        }
+        const runLegacyAfterSchema = (schemaOutcome) => {
+            if (!options.validate)
+                return schemaOutcome;
+            const legacyInput = schemaOutcome.hasValue ? schemaOutcome.value : data;
+            const legacyOutcome = runLegacyValidation(legacyInput);
+            if (!isPromiseLike(legacyOutcome)) {
+                return mergeValidationOutcomes([schemaOutcome, legacyOutcome]);
             }
-            else {
-                // Assume it's FieldErrors
-                const fieldErrors = result;
-                errors.set(fieldErrors);
-                return Object.keys(fieldErrors).length === 0;
+            return Promise.resolve(legacyOutcome).then((resolvedLegacy) => mergeValidationOutcomes([schemaOutcome, resolvedLegacy]));
+        };
+        if (options.schema) {
+            const schemaOutcome = runSchemaValidation(data, opts.path);
+            if (!isPromiseLike(schemaOutcome)) {
+                return runLegacyAfterSchema(schemaOutcome);
             }
+            return Promise.resolve(schemaOutcome).then((resolvedSchema) => runLegacyAfterSchema(resolvedSchema));
+        }
+        return runLegacyValidation(data);
+    }
+    function finalizeValidation(token, sourceData, outcome, opts = {}) {
+        if (!isValidationCurrent(token)) {
+            return { isValid: false, data: sourceData };
+        }
+        const isValid = applyValidationOutcome(outcome, opts.path);
+        const data = outcome.hasValue ? outcome.value : sourceData;
+        return { isValid, data };
+    }
+    // Validation
+    function validate(data, opts = {}) {
+        const token = beginValidation(opts.path);
+        const outcome = resolveValidationOutcome(data, opts);
+        if (!isPromiseLike(outcome)) {
+            return finalizeValidation(token, data, outcome, opts).isValid;
+        }
+        return outcome.then((resolved) => finalizeValidation(token, data, resolved, opts).isValid);
+    }
+    function validateForSubmit(data) {
+        const token = beginValidation();
+        const outcome = resolveValidationOutcome(data);
+        if (!isPromiseLike(outcome)) {
+            return finalizeValidation(token, data, outcome);
         }
-        return true;
+        return outcome.then((resolved) => finalizeValidation(token, data, resolved));
     }
     // Field Registry
     function _registerField(path, element) {
@@ -423,16 +730,25 @@ export function createForm(options = {}) {
                 const fd = new FormData(formElement);
                 const parser = options.parse ?? parseFormData;
                 const data = parser(formElement, fd);
-                validate(data);
+                const result = validate(data, { path: currentPath });
+                if (isPromiseLike(result)) {
+                    void result.catch((err) => {
+                        if (typeof console !== 'undefined') {
+                            console.error('[Dalila] Field validation failed:', err);
+                        }
+                    });
+                }
             }
         };
         element.addEventListener('blur', handleBlur);
         // Setup change handler for dirty + validation
         const handleChange = () => {
-            if (!defaultsInitialized)
-                return;
             // Use dynamic path lookup instead of captured path
             const currentPath = getCurrentPath();
+            if (!defaultsInitialized) {
+                notifyWatchers(currentPath);
+                return;
+            }
             const input = element;
             const defaultValue = getNestedValue(defaultValues, currentPath);
             let currentValue;
@@ -487,8 +803,16 @@ export function createForm(options = {}) {
                 const fd = new FormData(formElement);
                 const parser = options.parse ?? parseFormData;
                 const data = parser(formElement, fd);
-                validate(data);
+                const result = validate(data, { path: currentPath });
+                if (isPromiseLike(result)) {
+                    void result.catch((err) => {
+                        if (typeof console !== 'undefined') {
+                            console.error('[Dalila] Field validation failed:', err);
+                        }
+                    });
+                }
             }
+            notifyWatchers(currentPath);
         };
         element.addEventListener('change', handleChange);
         element.addEventListener('input', handleChange);
@@ -525,13 +849,14 @@ export function createForm(options = {}) {
                 const parser = options.parse ?? parseFormData;
                 const data = parser(form, fd);
                 // Validate
-                const isValid = validate(data);
+                const validation = await Promise.resolve(validateForSubmit(data));
+                const isValid = validation.isValid;
                 if (!isValid) {
                     focus(); // Focus first error
                     return;
                 }
                 // Call handler
-                await handler(data, { signal });
+                await handler(validation.data, { signal });
                 // If aborted, don't do anything
                 if (signal.aborted)
                     return;
@@ -672,6 +997,7 @@ export function createForm(options = {}) {
         submitController?.abort();
         submitController = null;
         submittingSignal.set(false);
+        notifyWatchers(undefined, { preferFieldArrayPaths: fieldArrayRegistry.keys() });
     }
     // Field Arrays
     function fieldArray(path) {
@@ -683,11 +1009,14 @@ export function createForm(options = {}) {
         const array = createFieldArray(path, {
             form: formElement,
             scope,
+            onMutate: () => notifyWatchers(path, { preferFieldArrayPath: path }),
             // Pass meta-state signals for remapping on reorder
             errors,
             touchedSet,
             dirtySet,
         });
+        // Register before hydration so watch reads can see this array immediately.
+        fieldArrayRegistry.set(path, array);
         // Initialize from defaultValues if available
         // When d-array is first rendered, it should start with values from defaultValues
         if (defaultsInitialized) {
@@ -696,7 +1025,6 @@ export function createForm(options = {}) {
                 array.replace(initialValue);
             }
         }
-        fieldArrayRegistry.set(path, array);
         return array;
     }
     // Getters
@@ -711,6 +1039,7 @@ export function createForm(options = {}) {
     }
     function _setFormElement(form) {
         formElement = form;
+        notifyWatchers();
     }
     // Cleanup on scope disposal
     if (scope) {
@@ -718,6 +1047,7 @@ export function createForm(options = {}) {
             submitController?.abort();
             fieldRegistry.clear();
             fieldArrayRegistry.clear();
+            pathWatchers.clear();
         });
     }
     return {
@@ -733,6 +1063,7 @@ export function createForm(options = {}) {
         submitting,
         submitCount,
         focus,
+        watch,
         _registerField,
         _getFormElement,
         _setFormElement,
@@ -844,6 +1175,7 @@ function createFieldArray(basePath, options) {
             newKeys.forEach((key, i) => next.set(key, items[i]));
             return next;
         });
+        options.onMutate?.();
     }
     function remove(key) {
         const removeIndex = _getIndex(key);
@@ -905,6 +1237,7 @@ function createFieldArray(basePath, options) {
                 remapMetaState(oldIndices, newIndices);
             }
         }
+        options.onMutate?.();
     }
     function removeAt(index) {
         if (index < 0 || index >= keys().length)
@@ -939,6 +1272,7 @@ function createFieldArray(basePath, options) {
             next.set(key, value);
             return next;
         });
+        options.onMutate?.();
     }
     function move(fromIndex, toIndex) {
         const len = keys().length;
@@ -974,6 +1308,7 @@ function createFieldArray(basePath, options) {
             next.splice(toIndex, 0, item);
             return next;
         });
+        options.onMutate?.();
     }
     function swap(indexA, indexB) {
         const len = keys().length;
@@ -988,6 +1323,7 @@ function createFieldArray(basePath, options) {
             [next[indexA], next[indexB]] = [next[indexB], next[indexA]];
             return next;
         });
+        options.onMutate?.();
     }
     function replace(newValues) {
         const newKeys = newValues.map(() => generateKey());
@@ -1027,6 +1363,7 @@ function createFieldArray(basePath, options) {
         }
         keys.set(newKeys);
         values.set(new Map(newKeys.map((key, i) => [key, newValues[i]])));
+        options.onMutate?.();
     }
     function update(key, value) {
         values.update((prev) => {
@@ -1034,6 +1371,7 @@ function createFieldArray(basePath, options) {
             next.set(key, value);
             return next;
         });
+        options.onMutate?.();
     }
     function updateAt(index, value) {
         if (index < 0 || index >= keys().length)

package/dist/form/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./form-types.js";
 export { createForm, parseFormData } from "./form.js";
+export { zodAdapter, valibotAdapter, yupAdapter } from "./schema-adapters.js";

package/dist/form/index.js

@@ -1,2 +1,3 @@
 export * from "./form-types.js";
 export { createForm, parseFormData } from "./form.js";
+export { zodAdapter, valibotAdapter, yupAdapter } from "./schema-adapters.js";

package/dist/form/schema-adapters.d.ts

@@ -0,0 +1,14 @@
+import type { FormSchemaAdapter } from "./form-types.js";
+interface ValibotRuntime {
+    safeParseAsync?: (schema: unknown, input: unknown) => Promise<unknown>;
+    safeParse?: (schema: unknown, input: unknown) => unknown;
+    parseAsync?: (schema: unknown, input: unknown) => Promise<unknown>;
+    parse?: (schema: unknown, input: unknown) => unknown;
+}
+declare global {
+    var valibot: ValibotRuntime | undefined;
+}
+export declare function zodAdapter<T = unknown>(schema: unknown): FormSchemaAdapter<T>;
+export declare function valibotAdapter<T = unknown>(schema: unknown, runtime?: ValibotRuntime): FormSchemaAdapter<T>;
+export declare function yupAdapter<T = unknown>(schema: unknown): FormSchemaAdapter<T>;
+export {};

package/dist/form/schema-adapters.js

@@ -0,0 +1,304 @@
+let resolvedValibotRuntime;
+let pendingValibotRuntime = null;
+let attemptedValibotModuleImport = false;
+function isPathRelated(pathA, pathB) {
+    if (pathA === pathB)
+        return true;
+    if (pathA.startsWith(`${pathB}.`) || pathA.startsWith(`${pathB}[`))
+        return true;
+    if (pathB.startsWith(`${pathA}.`) || pathB.startsWith(`${pathA}[`))
+        return true;
+    return false;
+}
+function normalizePathSegment(segment) {
+    if (typeof segment === "string" || typeof segment === "number")
+        return segment;
+    if (!segment || typeof segment !== "object")
+        return null;
+    if ("key" in segment) {
+        const key = segment.key;
+        if (typeof key === "string" || typeof key === "number")
+            return key;
+    }
+    if ("path" in segment) {
+        const path = segment.path;
+        if (typeof path === "string" || typeof path === "number")
+            return path;
+    }
+    return null;
+}
+function normalizePath(path) {
+    if (typeof path === "string")
+        return path;
+    if (typeof path === "number")
+        return `[${path}]`;
+    if (!Array.isArray(path))
+        return undefined;
+    let out = "";
+    for (const segment of path) {
+        const normalized = normalizePathSegment(segment);
+        if (normalized == null)
+            continue;
+        if (typeof normalized === "number") {
+            out += `[${normalized}]`;
+        }
+        else if (out.length === 0) {
+            out += normalized;
+        }
+        else {
+            out += `.${normalized}`;
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+function filterIssuesByPath(issues, path) {
+    if (!issues || issues.length === 0)
+        return [];
+    return issues.filter((issue) => issue.path && isPathRelated(issue.path, path));
+}
+function normalizeAdapterFailure(error, map) {
+    const issues = map(error);
+    if (issues.length > 0) {
+        return { issues };
+    }
+    return {
+        issues: [],
+        formError: error instanceof Error ? error.message : "Schema validation failed",
+    };
+}
+function mapZodIssues(error) {
+    const issues = error?.issues;
+    if (!Array.isArray(issues))
+        return [];
+    const normalized = [];
+    for (const issue of issues) {
+        if (!issue || typeof issue !== "object")
+            continue;
+        const message = issue.message;
+        if (typeof message !== "string" || message.length === 0)
+            continue;
+        normalized.push({
+            path: normalizePath(issue.path),
+            message,
+        });
+    }
+    return normalized;
+}
+function mapValibotIssues(error) {
+    const issues = error?.issues;
+    if (!Array.isArray(issues))
+        return [];
+    const normalized = [];
+    for (const issue of issues) {
+        if (!issue || typeof issue !== "object")
+            continue;
+        const message = issue.message;
+        if (typeof message !== "string" || message.length === 0)
+            continue;
+        normalized.push({
+            path: normalizePath(issue.path),
+            message,
+        });
+    }
+    return normalized;
+}
+async function runSafeParseSchema(schema, data) {
+    const s = schema;
+    if (typeof s.safeParseAsync === "function") {
+        const result = await s.safeParseAsync(data);
+        const success = result?.success === true;
+        if (success) {
+            return { ok: true, value: result.data };
+        }
+        return { ok: false, error: result.error };
+    }
+    if (typeof s.safeParse === "function") {
+        const result = s.safeParse(data);
+        const success = result?.success === true;
+        if (success) {
+            return { ok: true, value: result.data };
+        }
+        return { ok: false, error: result.error };
+    }
+    try {
+        if (typeof s.parseAsync === "function") {
+            return { ok: true, value: await s.parseAsync(data) };
+        }
+        if (typeof s.parse === "function") {
+            return { ok: true, value: s.parse(data) };
+        }
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+    throw new Error("Invalid schema adapter input: expected safeParse/parse methods.");
+}
+async function resolveValibotRuntime(runtime) {
+    if (runtime)
+        return runtime;
+    const globalRuntime = globalThis.valibot;
+    if (globalRuntime) {
+        resolvedValibotRuntime = globalRuntime;
+        return globalRuntime;
+    }
+    if (resolvedValibotRuntime)
+        return resolvedValibotRuntime;
+    if (attemptedValibotModuleImport)
+        return null;
+    if (!pendingValibotRuntime) {
+        attemptedValibotModuleImport = true;
+        pendingValibotRuntime = (async () => {
+            try {
+                const modName = "valibot";
+                const imported = await import(modName);
+                const moduleRuntime = imported;
+                resolvedValibotRuntime = moduleRuntime;
+                return moduleRuntime;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                pendingValibotRuntime = null;
+            }
+        })();
+    }
+    return pendingValibotRuntime;
+}
+async function runValibotParse(schema, data, runtime) {
+    const resolvedRuntime = await resolveValibotRuntime(runtime);
+    if (resolvedRuntime) {
+        if (typeof resolvedRuntime.safeParseAsync === "function") {
+            const result = await resolvedRuntime.safeParseAsync(schema, data);
+            const success = result?.success === true;
+            if (success) {
+                return { ok: true, value: result.output ?? result.data };
+            }
+            return { ok: false, error: result.issues ? { issues: result.issues } : result.error };
+        }
+        if (typeof resolvedRuntime.safeParse === "function") {
+            const result = resolvedRuntime.safeParse(schema, data);
+            const success = result?.success === true;
+            if (success) {
+                return { ok: true, value: result.output ?? result.data };
+            }
+            return { ok: false, error: result.issues ? { issues: result.issues } : result.error };
+        }
+        try {
+            if (typeof resolvedRuntime.parseAsync === "function") {
+                return { ok: true, value: await resolvedRuntime.parseAsync(schema, data) };
+            }
+            if (typeof resolvedRuntime.parse === "function") {
+                return { ok: true, value: resolvedRuntime.parse(schema, data) };
+            }
+        }
+        catch (error) {
+            return { ok: false, error };
+        }
+    }
+    try {
+        return await runSafeParseSchema(schema, data);
+    }
+    catch {
+        throw new Error("Invalid valibot adapter input: expected valibot safeParse(schema, input) runtime or schema parse methods.");
+    }
+}
+export function zodAdapter(schema) {
+    function mapErrors(error) {
+        return mapZodIssues(error);
+    }
+    const runValidate = async (data) => {
+        const result = await runSafeParseSchema(schema, data);
+        if (result.ok) {
+            return { value: result.value, issues: [] };
+        }
+        return normalizeAdapterFailure(result.error, mapErrors);
+    };
+    return {
+        validate: runValidate,
+        async validateField(path, _value, data) {
+            const full = await runValidate(data);
+            return { ...full, issues: filterIssuesByPath(full.issues, path) };
+        },
+        mapErrors,
+    };
+}
+export function valibotAdapter(schema, runtime) {
+    function mapErrors(error) {
+        return mapValibotIssues(error);
+    }
+    const runValidate = async (data) => {
+        const result = await runValibotParse(schema, data, runtime);
+        if (result.ok) {
+            return { value: result.value, issues: [] };
+        }
+        return normalizeAdapterFailure(result.error, mapErrors);
+    };
+    return {
+        validate: runValidate,
+        async validateField(path, _value, data) {
+            const full = await runValidate(data);
+            return { ...full, issues: filterIssuesByPath(full.issues, path) };
+        },
+        mapErrors,
+    };
+}
+function mapYupError(error) {
+    const err = error;
+    const mapped = [];
+    if (Array.isArray(err.inner) && err.inner.length > 0) {
+        for (const item of err.inner) {
+            if (!item || typeof item.message !== "string")
+                continue;
+            mapped.push({ path: typeof item.path === "string" ? item.path : undefined, message: item.message });
+        }
+        return mapped;
+    }
+    if (typeof err.message === "string" && err.message.length > 0) {
+        mapped.push({
+            path: typeof err.path === "string" ? err.path : undefined,
+            message: err.message,
+        });
+    }
+    return mapped;
+}
+export function yupAdapter(schema) {
+    const s = schema;
+    function mapErrors(error) {
+        return mapYupError(error);
+    }
+    const runValidate = async (data) => {
+        if (typeof s.validate !== "function") {
+            throw new Error("Invalid yup schema adapter input: expected validate().");
+        }
+        try {
+            const value = await s.validate(data, { abortEarly: false });
+            return { value: value, issues: [] };
+        }
+        catch (error) {
+            return normalizeAdapterFailure(error, mapErrors);
+        }
+    };
+    return {
+        validate: runValidate,
+        async validateField(path, _value, data) {
+            if (typeof s.validateAt === "function") {
+                try {
+                    await s.validateAt(path, data, { abortEarly: false });
+                    return { issues: [] };
+                }
+                catch (error) {
+                    const normalized = normalizeAdapterFailure(error, mapErrors);
+                    const formLevelIssue = (normalized.issues ?? []).find((issue) => !issue.path);
+                    return {
+                        formError: normalized.formError ?? formLevelIssue?.message,
+                        issues: filterIssuesByPath(normalized.issues, path),
+                    };
+                }
+            }
+            const full = await runValidate(data);
+            return { ...full, issues: filterIssuesByPath(full.issues, path) };
+        },
+        mapErrors,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dalila",
-  "version": "1.9.13",
+  "version": "1.9.14",
   "description": "DOM-first reactive framework based on signals",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",