vee-validate 4.15.1 → 5.0.0-beta.1

package/dist/vee-validate.iife.js

@@ -1,6 +1,6 @@
 /**
-  * vee-validate v4.15.1
-  * (c) 2025 Abdelrahman Awad
+  * vee-validate v5.0.0-beta.1
+  * (c) 2026 Abdelrahman Awad
   * @license MIT
   */
 var VeeValidate = (function (exports, vue) {
@@ -163,11 +163,8 @@ var VeeValidate = (function (exports, vue) {
     function isLocator(value) {
         return isCallable(value) && !!value.__locatorRef;
     }
-    function isTypedSchema(value) {
-        return !!value && isCallable(value.parse) && value.__type === 'VVTypedSchema';
-    }
-    function isYupValidator(value) {
-        return !!value && isCallable(value.validate);
+    function isStandardSchema(value) {
+        return isObject(value) && '~standard' in value;
     }
     function hasCheckedAttr(type) {
         return type === 'checkbox' || type === 'radio';
@@ -347,6 +344,27 @@ var VeeValidate = (function (exports, vue) {
         return a instanceof File;
     }
 
+    // src/getDotPath/getDotPath.ts
+    function getDotPath(issue) {
+      if (issue.path?.length) {
+        let dotPath = "";
+        for (const item of issue.path) {
+          const key = typeof item === "object" ? item.key : item;
+          if (typeof key === "string" || typeof key === "number") {
+            if (dotPath) {
+              dotPath += `.${key}`;
+            } else {
+              dotPath += key;
+            }
+          } else {
+            return null;
+          }
+        }
+        return dotPath;
+      }
+      return null;
+    }
+
     function cleanupNonNestedPath(path) {
         if (isNotNestedPath(path)) {
             return path.replace(/\[|\]/gi, '');
@@ -562,6 +580,31 @@ var VeeValidate = (function (exports, vue) {
             return new Promise(resolve => resolves.push(resolve));
         };
     }
+    function _combineIssueItems(items, getPath) {
+        const issueMap = {};
+        for (const item of items) {
+            const path = getPath(item);
+            if (!issueMap[path]) {
+                issueMap[path] = {
+                    path,
+                    messages: [],
+                };
+            }
+            if ('messages' in item) {
+                issueMap[path].messages.push(...item.messages);
+            }
+            else {
+                issueMap[path].messages.push(item.message);
+            }
+        }
+        return Object.values(issueMap);
+    }
+    /**
+     * Aggregates standard schema issues by path.
+     */
+    function combineStandardIssues(issues) {
+        return _combineIssueItems(issues, issue => { var _a; return (issue.path ? (_a = getDotPath(issue)) !== null && _a !== void 0 ? _a : '' : ''); });
+    }
 
     function normalizeChildren(tag, context, slotProps) {
         if (!context.slots.default) {
@@ -593,9 +636,6 @@ var VeeValidate = (function (exports, vue) {
     }
 
     function parseInputValue(el) {
-        if (el.type === 'number') {
-            return Number.isNaN(el.valueAsNumber) ? el.value : el.valueAsNumber;
-        }
         if (el.type === 'range') {
             return Number.isNaN(el.valueAsNumber) ? el.value : el.valueAsNumber;
         }
@@ -768,8 +808,8 @@ var VeeValidate = (function (exports, vue) {
      */
     async function _validate(field, value) {
         const rules = field.rules;
-        if (isTypedSchema(rules) || isYupValidator(rules)) {
-            return validateFieldWithTypedSchema(value, Object.assign(Object.assign({}, field), { rules }));
+        if (isStandardSchema(rules)) {
+            return validateFieldWithStandardSchema(value, Object.assign(Object.assign({}, field), { rules }));
         }
         // if a generic function or chain of generic functions
         if (isCallable(rules) || Array.isArray(rules)) {
@@ -831,58 +871,24 @@ var VeeValidate = (function (exports, vue) {
             errors,
         };
     }
-    function isYupError(err) {
-        return !!err && err.name === 'ValidationError';
-    }
-    function yupToTypedSchema(yupSchema) {
-        const schema = {
-            __type: 'VVTypedSchema',
-            async parse(values, context) {
-                var _a;
-                try {
-                    const output = await yupSchema.validate(values, { abortEarly: false, context: (context === null || context === void 0 ? void 0 : context.formData) || {} });
-                    return {
-                        output,
-                        errors: [],
-                    };
-                }
-                catch (err) {
-                    // Yup errors have a name prop one them.
-                    // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string
-                    if (!isYupError(err)) {
-                        throw err;
-                    }
-                    if (!((_a = err.inner) === null || _a === void 0 ? void 0 : _a.length) && err.errors.length) {
-                        return { errors: [{ path: err.path, errors: err.errors }] };
-                    }
-                    const errors = err.inner.reduce((acc, curr) => {
-                        const path = curr.path || '';
-                        if (!acc[path]) {
-                            acc[path] = { errors: [], path };
-                        }
-                        acc[path].errors.push(...curr.errors);
-                        return acc;
-                    }, {});
-                    return { errors: Object.values(errors) };
-                }
-            },
-        };
-        return schema;
-    }
     /**
      * Handles yup validation
      */
-    async function validateFieldWithTypedSchema(value, context) {
-        const typedSchema = isTypedSchema(context.rules) ? context.rules : yupToTypedSchema(context.rules);
-        const result = await typedSchema.parse(value, { formData: context.formData });
+    async function validateFieldWithStandardSchema(value, context) {
+        const result = await context.rules['~standard'].validate(value);
+        if (!result.issues) {
+            return {
+                value: result.value,
+                errors: [],
+            };
+        }
         const messages = [];
-        for (const error of result.errors) {
-            if (error.errors.length) {
-                messages.push(...error.errors);
+        for (const error of result.issues) {
+            if (error.message) {
+                messages.push(error.message);
             }
         }
         return {
-            value: result.value,
             errors: messages,
         };
     }
@@ -938,27 +944,33 @@ var VeeValidate = (function (exports, vue) {
             return acc;
         }, {});
     }
-    async function validateTypedSchema(schema, values) {
-        const typedSchema = isTypedSchema(schema) ? schema : yupToTypedSchema(schema);
-        const validationResult = await typedSchema.parse(klona(values), { formData: klona(values) });
+    async function validateStandardSchema(schema, values) {
+        const validationResult = await schema['~standard'].validate(klona(values));
         const results = {};
         const errors = {};
-        for (const error of validationResult.errors) {
-            const messages = error.errors;
-            // Fixes issue with path mapping with Yup 1.0 including quotes around array indices
-            const path = (error.path || '').replace(/\["(\d+)"\]/g, (_, m) => {
-                return `[${m}]`;
-            });
+        if (!validationResult.issues) {
+            return {
+                valid: true,
+                results: {},
+                errors: {},
+                values: validationResult.value,
+                source: 'schema',
+            };
+        }
+        const combinedIssues = combineStandardIssues(validationResult.issues || []);
+        for (const error of combinedIssues) {
+            const messages = error.messages;
+            const path = error.path;
             results[path] = { valid: !messages.length, errors: messages };
             if (messages.length) {
                 errors[path] = messages[0];
             }
         }
         return {
-            valid: !validationResult.errors.length,
+            valid: !combinedIssues.length,
             results,
             errors,
-            values: validationResult.value,
+            values: undefined,
             source: 'schema',
         };
     }
@@ -1003,7 +1015,7 @@ var VeeValidate = (function (exports, vue) {
         if (!init.form) {
             const { errors, setErrors } = createFieldErrors();
             const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;
-            const meta = createFieldMeta(value, initialValue, errors, init.schema);
+            const meta = createFieldMeta(value, initialValue, errors);
             function setState(state) {
                 var _a;
                 if ('value' in state) {
@@ -1035,7 +1047,6 @@ var VeeValidate = (function (exports, vue) {
             label: init.label,
             type: init.type,
             validate: init.validate,
-            schema: init.schema,
         });
         const errors = vue.computed(() => state.errors);
         function setState(state) {
@@ -1131,13 +1142,11 @@ var VeeValidate = (function (exports, vue) {
     /**
      * Creates meta flags state and some associated effects with them
      */
-    function createFieldMeta(currentValue, initialValue, errors, schema) {
-        const isRequired = vue.computed(() => { var _a, _b, _c; return (_c = (_b = (_a = vue.toValue(schema)) === null || _a === void 0 ? void 0 : _a.describe) === null || _b === void 0 ? void 0 : _b.call(_a).required) !== null && _c !== void 0 ? _c : false; });
+    function createFieldMeta(currentValue, initialValue, errors) {
         const meta = vue.reactive({
             touched: false,
             pending: false,
             valid: true,
-            required: isRequired,
             validated: !!vue.unref(errors).length,
             initialValue: vue.computed(() => vue.unref(initialValue)),
             dirty: vue.computed(() => {
@@ -1185,15 +1194,11 @@ var VeeValidate = (function (exports, vue) {
                 return undefined;
             }
             const rulesValue = vue.unref(rules);
-            if (isYupValidator(rulesValue) ||
-                isTypedSchema(rulesValue) ||
-                isCallable(rulesValue) ||
-                Array.isArray(rulesValue)) {
+            if (isStandardSchema(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {
                 return rulesValue;
             }
             return normalizeRules(rulesValue);
         });
-        const isTyped = !isCallable(validator.value) && isTypedSchema(vue.toValue(rules));
         const { id, value, initialValue, meta, setState, errors, flags } = useFieldState(name, {
             modelValue,
             form,
@@ -1201,7 +1206,6 @@ var VeeValidate = (function (exports, vue) {
             label,
             type,
             validate: validator.value ? validate$1 : undefined,
-            schema: isTyped ? rules : undefined,
         });
         const errorMessage = vue.computed(() => errors.value[0]);
         if (syncVModel) {
@@ -1353,12 +1357,8 @@ var VeeValidate = (function (exports, vue) {
         // extract cross-field dependencies in a computed prop
         const dependencies = vue.computed(() => {
             const rulesVal = validator.value;
-            // is falsy, a function schema or a yup schema
-            if (!rulesVal ||
-                isCallable(rulesVal) ||
-                isYupValidator(rulesVal) ||
-                isTypedSchema(rulesVal) ||
-                Array.isArray(rulesVal)) {
+            // is falsy, a function schema or a standard schema
+            if (!rulesVal || isCallable(rulesVal) || isStandardSchema(rulesVal) || Array.isArray(rulesVal)) {
                 return {};
             }
             return Object.keys(rulesVal).reduce((acc, rule) => {
@@ -1424,6 +1424,7 @@ var VeeValidate = (function (exports, vue) {
      * Normalizes partial field options to include the full options
      */
     function normalizeOptions(opts) {
+        var _a;
         const defaults = () => ({
             initialValue: undefined,
             validateOnMount: false,
@@ -1435,22 +1436,19 @@ var VeeValidate = (function (exports, vue) {
             controlled: true,
         });
         const isVModelSynced = !!(opts === null || opts === void 0 ? void 0 : opts.syncVModel);
-        const modelPropName = typeof (opts === null || opts === void 0 ? void 0 : opts.syncVModel) === 'string' ? opts.syncVModel : (opts === null || opts === void 0 ? void 0 : opts.modelPropName) || 'modelValue';
+        const modelPropName = typeof (opts === null || opts === void 0 ? void 0 : opts.syncVModel) === 'string' ? opts.syncVModel : 'modelValue';
         const initialValue = isVModelSynced && !('initialValue' in (opts || {}))
             ? getCurrentModelValue(vue.getCurrentInstance(), modelPropName)
             : opts === null || opts === void 0 ? void 0 : opts.initialValue;
         if (!opts) {
             return Object.assign(Object.assign({}, defaults()), { initialValue });
         }
-        // TODO: Deprecate this in next major release
-        const checkedValue = 'valueProp' in opts ? opts.valueProp : opts.checkedValue;
-        const controlled = 'standalone' in opts ? !opts.standalone : opts.controlled;
-        const syncVModel = (opts === null || opts === void 0 ? void 0 : opts.modelPropName) || (opts === null || opts === void 0 ? void 0 : opts.syncVModel) || false;
-        return Object.assign(Object.assign(Object.assign({}, defaults()), (opts || {})), { initialValue, controlled: controlled !== null && controlled !== void 0 ? controlled : true, checkedValue,
-            syncVModel });
+        const controlled = (_a = opts.controlled) !== null && _a !== void 0 ? _a : true;
+        const syncVModel = (opts === null || opts === void 0 ? void 0 : opts.syncVModel) || false;
+        return Object.assign(Object.assign(Object.assign({}, defaults()), (opts || {})), { initialValue, controlled: controlled !== null && controlled !== void 0 ? controlled : true, checkedValue: opts === null || opts === void 0 ? void 0 : opts.checkedValue, syncVModel });
     }
     function useFieldWithChecked(name, rules, opts) {
-        const form = !(opts === null || opts === void 0 ? void 0 : opts.standalone) ? injectWithSelf(FormContextKey) : undefined;
+        const form = (opts === null || opts === void 0 ? void 0 : opts.controlled) ? injectWithSelf(FormContextKey) : undefined;
         const checkedValue = opts === null || opts === void 0 ? void 0 : opts.checkedValue;
         const uncheckedValue = opts === null || opts === void 0 ? void 0 : opts.uncheckedValue;
         function patchCheckedApi(field) {
@@ -1584,9 +1582,9 @@ var VeeValidate = (function (exports, vue) {
                 type: null,
                 default: undefined,
             },
-            standalone: {
+            controlled: {
                 type: Boolean,
-                default: false,
+                default: true,
             },
             keepValue: {
                 type: Boolean,
@@ -1602,7 +1600,7 @@ var VeeValidate = (function (exports, vue) {
             const { errors, value, errorMessage, validate: validateField, handleChange, handleBlur, setTouched, resetField, handleReset, meta, checked, setErrors, setValue, } = useField(name, rules, {
                 validateOnMount: props.validateOnMount,
                 bails: props.bails,
-                standalone: props.standalone,
+                controlled: props.controlled,
                 type: ctx.attrs.type,
                 initialValue: resolveInitialValue(props, ctx),
                 // Only for checkboxes and radio buttons
@@ -1733,10 +1731,6 @@ var VeeValidate = (function (exports, vue) {
     function resolveInitialValues(opts) {
         const givenInitial = (opts === null || opts === void 0 ? void 0 : opts.initialValues) || {};
         const providedValues = Object.assign({}, vue.toValue(givenInitial));
-        const schema = vue.unref(opts === null || opts === void 0 ? void 0 : opts.validationSchema);
-        if (schema && isTypedSchema(schema) && isCallable(schema.cast)) {
-            return klona(schema.cast(providedValues) || {});
-        }
         return klona(providedValues);
     }
     function useForm(opts) {
@@ -1871,19 +1865,6 @@ var VeeValidate = (function (exports, vue) {
             if (unsetBatchIndex !== -1) {
                 UNSET_BATCH.splice(unsetBatchIndex, 1);
             }
-            const isRequired = vue.computed(() => {
-                var _a, _b, _c, _d;
-                const schemaValue = vue.toValue(schema);
-                if (isTypedSchema(schemaValue)) {
-                    return (_b = (_a = schemaValue.describe) === null || _a === void 0 ? void 0 : _a.call(schemaValue, vue.toValue(path)).required) !== null && _b !== void 0 ? _b : false;
-                }
-                // Path own schema
-                const configSchemaValue = vue.toValue(config === null || config === void 0 ? void 0 : config.schema);
-                if (isTypedSchema(configSchemaValue)) {
-                    return (_d = (_c = configSchemaValue.describe) === null || _c === void 0 ? void 0 : _c.call(configSchemaValue).required) !== null && _d !== void 0 ? _d : false;
-                }
-                return false;
-            });
             const id = FIELD_ID_COUNTER++;
             const state = vue.reactive({
                 id,
@@ -1892,7 +1873,6 @@ var VeeValidate = (function (exports, vue) {
                 pending: false,
                 valid: true,
                 validated: !!((_a = initialErrors[pathValue]) === null || _a === void 0 ? void 0 : _a.length),
-                required: isRequired,
                 initialValue,
                 errors: vue.shallowRef([]),
                 bails: (_b = config === null || config === void 0 ? void 0 : config.bails) !== null && _b !== void 0 ? _b : false,
@@ -2167,9 +2147,6 @@ var VeeValidate = (function (exports, vue) {
             resetForm,
             resetField,
             handleSubmit,
-            useFieldModel,
-            defineInputBinds,
-            defineComponentBinds: defineComponentBinds,
             defineField,
             stageInitialValue,
             unsetInitialValue,
@@ -2305,7 +2282,6 @@ var VeeValidate = (function (exports, vue) {
         function resetForm(resetState, opts) {
             let newValues = klona((resetState === null || resetState === void 0 ? void 0 : resetState.values) ? resetState.values : originalInitialValues.value);
             newValues = (opts === null || opts === void 0 ? void 0 : opts.force) ? newValues : merge(originalInitialValues.value, newValues);
-            newValues = isTypedSchema(schema) && isCallable(schema.cast) ? schema.cast(newValues) : newValues;
             setInitialValues(newValues, { force: opts === null || opts === void 0 ? void 0 : opts.force });
             mutateAllPathState(state => {
                 var _a;
@@ -2418,8 +2394,8 @@ var VeeValidate = (function (exports, vue) {
                 return { valid: true, results: {}, errors: {}, source: 'none' };
             }
             isValidating.value = true;
-            const formResult = isYupValidator(schemaValue) || isTypedSchema(schemaValue)
-                ? await validateTypedSchema(schemaValue, formValues)
+            const formResult = isStandardSchema(schemaValue)
+                ? await validateStandardSchema(schemaValue, formValues)
                 : await validateObjectSchema(schemaValue, formValues, {
                     names: fieldNames.value,
                     bailsMap: fieldBailsMap.value,
@@ -2506,50 +2482,6 @@ var VeeValidate = (function (exports, vue) {
             const model = createModel(path, () => { var _a, _b, _c; return (_c = (_a = evalConfig().validateOnModelUpdate) !== null && _a !== void 0 ? _a : (_b = getConfig()) === null || _b === void 0 ? void 0 : _b.validateOnModelUpdate) !== null && _c !== void 0 ? _c : true; });
             return [model, props];
         }
-        function useFieldModel(pathOrPaths) {
-            if (!Array.isArray(pathOrPaths)) {
-                return createModel(pathOrPaths);
-            }
-            return pathOrPaths.map(p => createModel(p, true));
-        }
-        /**
-         * @deprecated use defineField instead
-         */
-        function defineInputBinds(path, config) {
-            const [model, props] = defineField(path, config);
-            function onBlur() {
-                props.value.onBlur();
-            }
-            function onInput(e) {
-                const value = normalizeEventValue(e);
-                setFieldValue(vue.toValue(path), value, false);
-                props.value.onInput();
-            }
-            function onChange(e) {
-                const value = normalizeEventValue(e);
-                setFieldValue(vue.toValue(path), value, false);
-                props.value.onChange();
-            }
-            return vue.computed(() => {
-                return Object.assign(Object.assign({}, props.value), { onBlur,
-                    onInput,
-                    onChange, value: model.value });
-            });
-        }
-        /**
-         * @deprecated use defineField instead
-         */
-        function defineComponentBinds(path, config) {
-            const [model, props] = defineField(path, config);
-            const pathState = findPathState(vue.toValue(path));
-            function onUpdateModelValue(value) {
-                model.value = value;
-            }
-            return vue.computed(() => {
-                const conf = isCallable(config) ? config(omit(pathState, PRIVATE_PATH_STATE_KEYS)) : config || {};
-                return Object.assign({ [conf.model || 'modelValue']: model.value, [`onUpdate:${conf.model || 'modelValue'}`]: onUpdateModelValue }, props.value);
-            });
-        }
         const ctx = Object.assign(Object.assign({}, formCtx), { values: vue.readonly(formValues), handleReset: () => resetForm(), submitForm });
         vue.provide(PublicFormContextKey, ctx);
         return ctx;
@@ -3427,6 +3359,7 @@ var VeeValidate = (function (exports, vue) {
     exports.cleanupNonNestedPath = cleanupNonNestedPath;
     exports.configure = configure;
     exports.defineRule = defineRule;
+    exports.getConfig = getConfig;
     exports.isNotNestedPath = isNotNestedPath;
     exports.normalizeRules = normalizeRules;
     exports.useField = useField;