vee-validate 4.15.0 → 5.0.0-beta.0

package/dist/vee-validate.mjs

@@ -1,6 +1,6 @@
 /**
-  * vee-validate v4.15.0
-  * (c) 2024 Abdelrahman Awad
+  * vee-validate v5.0.0-beta.0
+  * (c) 2025 Abdelrahman Awad
   * @license MIT
   */
 import { getCurrentInstance, inject, warn as warn$1, computed, toValue, ref, watch, nextTick, unref, isRef, reactive, onUnmounted, onMounted, provide, onBeforeUnmount, defineComponent, toRef, resolveDynamicComponent, h, readonly, watchEffect, shallowRef } from 'vue';
@@ -162,11 +162,8 @@ const isClient = typeof window !== 'undefined';
 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';
@@ -310,14 +307,16 @@ function isEqual(a, b) {
             return a.valueOf() === b.valueOf();
         if (a.toString !== Object.prototype.toString)
             return a.toString() === b.toString();
+        // Remove undefined values before object comparison
+        a = normalizeObject(a);
+        b = normalizeObject(b);
         keys = Object.keys(a);
-        length = keys.length - countUndefinedValues(a, keys);
-        if (length !== Object.keys(b).length - countUndefinedValues(b, Object.keys(b)))
+        length = keys.length;
+        if (length !== Object.keys(b).length)
             return false;
-        for (i = length; i-- !== 0;) {
+        for (i = length; i-- !== 0;)
             if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
                 return false;
-        }
         for (i = length; i-- !== 0;) {
             // eslint-disable-next-line no-var
             var key = keys[i];
@@ -329,15 +328,13 @@ function isEqual(a, b) {
     // true if both NaN, false otherwise
     return a !== a && b !== b;
 }
-function countUndefinedValues(a, keys) {
-    let result = 0;
-    for (let i = keys.length; i-- !== 0;) {
-        // eslint-disable-next-line no-var
-        var key = keys[i];
-        if (a[key] === undefined)
-            result++;
-    }
-    return result;
+/**
+ * Returns a new object where keys with an `undefined` value are removed.
+ *
+ * @param a object to normalize
+ */
+function normalizeObject(a) {
+    return Object.fromEntries(Object.entries(a).filter(([, value]) => value !== undefined));
 }
 function isFile(a) {
     if (!isClient) {
@@ -346,6 +343,27 @@ function isFile(a) {
     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, '');
@@ -586,6 +604,31 @@ function debounceNextTick(inner) {
         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) {
@@ -792,8 +835,8 @@ async function validate(value, rules, options = {}) {
  */
 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)) {
@@ -855,58 +898,24 @@ async function _validate(field, value) {
         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,
     };
 }
@@ -962,27 +971,33 @@ function fillTargetValues(params, crossTable) {
         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',
     };
 }
@@ -1027,7 +1042,7 @@ function useFieldState(path, init) {
     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) {
@@ -1059,7 +1074,6 @@ function useFieldState(path, init) {
         label: init.label,
         type: init.type,
         validate: init.validate,
-        schema: init.schema,
     });
     const errors = computed(() => state.errors);
     function setState(state) {
@@ -1155,13 +1169,11 @@ function resolveModelValue(modelValue, form, initialValue, path) {
 /**
  * Creates meta flags state and some associated effects with them
  */
-function createFieldMeta(currentValue, initialValue, errors, schema) {
-    const isRequired = computed(() => { var _a, _b, _c; return (_c = (_b = (_a = 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 = reactive({
         touched: false,
         pending: false,
         valid: true,
-        required: isRequired,
         validated: !!unref(errors).length,
         initialValue: computed(() => unref(initialValue)),
         dirty: computed(() => {
@@ -1220,7 +1232,7 @@ async function installDevtoolsPlugin(app) {
             packageName: 'vee-validate',
             homepage: 'https://vee-validate.logaretm.com/v4',
             app,
-            logo: 'https://vee-validate.logaretm.com/v4/logo.png',
+            logo: 'https://vee-validate.logaretm.com/v5/logo.png',
         }, api => {
             API = api;
             api.addInspector({
@@ -1604,15 +1616,11 @@ function _useField(path, rules, opts) {
             return undefined;
         }
         const rulesValue = 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(toValue(rules));
     const { id, value, initialValue, meta, setState, errors, flags } = useFieldState(name, {
         modelValue,
         form,
@@ -1620,7 +1628,6 @@ function _useField(path, rules, opts) {
         label,
         type,
         validate: validator.value ? validate$1 : undefined,
-        schema: isTyped ? rules : undefined,
     });
     const errorMessage = computed(() => errors.value[0]);
     if (syncVModel) {
@@ -1781,12 +1788,8 @@ function _useField(path, rules, opts) {
     // extract cross-field dependencies in a computed prop
     const dependencies = 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) => {
@@ -2165,10 +2168,6 @@ const PRIVATE_PATH_STATE_KEYS = ['bails', 'fieldsCount', 'id', 'multiple', 'type
 function resolveInitialValues(opts) {
     const givenInitial = (opts === null || opts === void 0 ? void 0 : opts.initialValues) || {};
     const providedValues = Object.assign({}, toValue(givenInitial));
-    const schema = 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) {
@@ -2303,19 +2302,6 @@ function useForm(opts) {
         if (unsetBatchIndex !== -1) {
             UNSET_BATCH.splice(unsetBatchIndex, 1);
         }
-        const isRequired = computed(() => {
-            var _a, _b, _c, _d;
-            const schemaValue = toValue(schema);
-            if (isTypedSchema(schemaValue)) {
-                return (_b = (_a = schemaValue.describe) === null || _a === void 0 ? void 0 : _a.call(schemaValue, toValue(path)).required) !== null && _b !== void 0 ? _b : false;
-            }
-            // Path own schema
-            const configSchemaValue = 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 = reactive({
             id,
@@ -2324,7 +2310,6 @@ function useForm(opts) {
             pending: false,
             valid: true,
             validated: !!((_a = initialErrors[pathValue]) === null || _a === void 0 ? void 0 : _a.length),
-            required: isRequired,
             initialValue,
             errors: shallowRef([]),
             bails: (_b = config === null || config === void 0 ? void 0 : config.bails) !== null && _b !== void 0 ? _b : false,
@@ -2737,7 +2722,6 @@ function useForm(opts) {
     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;
@@ -2855,8 +2839,8 @@ function useForm(opts) {
             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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vee-validate",
-  "version": "4.15.0",
+  "version": "5.0.0-beta.0",
   "description": "Painless forms for Vue.js",
   "author": "Abdelrahman Awad <logaretm1@gmail.com>",
   "license": "MIT",
@@ -42,6 +42,8 @@
     "vue": "^3.4.26"
   },
   "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@standard-schema/utils": "^0.3.0",
     "@vue/devtools-api": "^7.5.2",
     "type-fest": "^4.8.3"
   }