Simple, lightweight model-based validation for Vue.js

Overview

vuelidate

codecov gzip size

Simple, lightweight model-based validation for Vue.js

Sponsors

Gold

Vuejs Amsterdam

Vue - The Road To Enterprise

Silver

Storyblok

Bronze

Vue Mastery logo Vue Mastery logo

Features & characteristics:

  • Model based
  • Decoupled from templates
  • Dependency free, minimalistic library
  • Support for collection validations
  • Support for nested models
  • Contextified validators
  • Easy to use with custom validators (e.g. Moment.js)
  • Support for function composition
  • Validates different data sources: Vuex getters, computed values, etc.

Demo & docs

https://vuelidate.js.org/

Vue 3 support

Vue 3 support is almost here with the Vuelidate 2 rewrite. Check out the next branch to see the latest progress.

Installation

npm install vuelidate --save

You can import the library and use as a Vue plugin to enable the functionality globally on all components containing validation configuration.

import Vue from 'vue'
import Vuelidate from 'vuelidate'
Vue.use(Vuelidate)

Alternatively it is possible to import a mixin directly to components in which it will be used.

import { validationMixin } from 'vuelidate'

var Component = Vue.extend({
  mixins: [validationMixin],
  validations: { ... }
})

The browser-ready bundle is also provided in the package.

<script src="vuelidate/dist/vuelidate.min.js">script>

<script src="vuelidate/dist/validators.min.js">script>
Vue.use(window.vuelidate.default)

Basic usage

For each value you want to validate, you have to create a key inside validations options. You can specify when input becomes dirty by using appropriate event on your input box.

import { required, minLength, between } from 'vuelidate/lib/validators'

export default {
  data () {
    return {
      name: '',
      age: 0
    }
  },
  validations: {
    name: {
      required,
      minLength: minLength(4)
    },
    age: {
      between: between(20, 30)
    }
  }
}

This will result in a validation object:

$v: {
  name: {
    "required": false,
    "minLength": false,
    "$invalid": true,
    "$dirty": false,
    "$error": false,
    "$pending": false
  },
  age: {
    "between": false
    "$invalid": true,
    "$dirty": false,
    "$error": false,
    "$pending": false
  }
}

Checkout the docs for more examples: https://vuelidate.js.org/

Contributing

# install dependencies
npm install

# serve with hot reload at localhost:8080
npm run dev

# create UMD bundle.
npm run build

# Create docs inside /gh-pages ready to be published
npm run docs

# run unit tests
npm run unit

# run all tests
npm test

For detailed explanation on how things work, checkout the guide and docs for vue-loader.

Contributors

Current

Damian Dulisz
Damian Dulisz
Natalia Tepluhina
Natalia Tepluhina
Natalia Tepluhina
Dobromir Hristov
Marina Mosti
Marina Mosti

Emeriti

Here we honor past contributors who have been a major part on this project.

License

MIT

Issues
  • @types/vuelidate

    @types/vuelidate

    Provide types as inspired by #175.

    Main types:

    • Vuelidate = PluginFunction for Vue.use(Vuelidate)
    • ComponentOptions.validations
    • Vue.$v

    Some of the predefined predicates are covered, may be not all.

    opened by janesser 64
  • $v is not defined in single file component

    $v is not defined in single file component

    I'm trying to use the vuelidate plugin with my vue-router-enabled web app. I keep getting the following error:

    [Vue-warn]: Property or method "$v" is not defined on the instance but referenced during render. Make sure to declare reactive data properties in the data option

    This is my bootstrap file for reference:

    `import Vue from 'vue' import Resource from 'vue-resource' import App from "./components/App.vue" import router from "./router/appRouter.js" import store from "./store/appStore.js"

    Vue.use(Resource); Vue.use(Vuelidate);

    const app = new Vue({ el: '#app', router, store, render: (h) => h(App) }) `

    I'm using the plugin with the following code in component file:

    <template>
    <div>
        <div :class="'input-group ' + {'form-group-error': $v.email.$error }"> 
        <p class="label"> Email </p>
        <input type="text" id="email" v-model="models.email" @input="$v.email.$touch">
        </div>
    </div>
    </template>
    
    <script>
        const { required, minLength, alpha, email, numeric } = require("vuelidate/lib/validators");
        export default 
        {
            data(){...},
            methods:{...},
            etc
        }
    <script>
    

    I can't figure out how to reference $v in my code to allow the vue instance to access it. Sorry in advance if I'm missing something blindingly obvious but I've stuck on this for a while

    Thanks

    opened by shiningshisa 42
  • Validator 'numeric' only accepts positive integers

    Validator 'numeric' only accepts positive integers

    The name of the validator implies it is looking for any numeric value, including decimal and negative values. The current implementation only accepts positive integers. Either the accepted validation text should be broadened or this validator should be renamed.

    Example: https://jsfiddle.net/gregpeden/hmcLdc5a/

    I could provide a PR for this (fix this + provide actual integer test) if there is interest in changing it.

    opened by GregPeden 32
  • version of $dirty that is true if any children have been changed

    version of $dirty that is true if any children have been changed

    I would also like to have a value that is similar to $dirty with the difference being that it is true if any (rather than all) of the children are $dirty. The purpose to make it easy to track if there have been any changes in the overall form or a specific section of the form - e.g. certain actions will be available if even only one value has changed.

    I am just not sure how best to do this. I understand that $dirty is a computed value, so preferably I would like to add a complementary computed value to $dirty (e.g. $anydirty) to be access in a similar manner to the $dirty value. If anyone in the know has some guidance on the best way to achieve this it would be greatly appreciated.

    enhancement 
    opened by michaelsorich 27
  • Vuelidate does not work with vue 3

    Vuelidate does not work with vue 3

    An Error occurs as soon as I uncomment the following line:

    function useApplicationPluginsAndComponents (Application) { // Application.use(VueCompositionAPI) // causing error Application.use(router) Application.use(store) registerGlobalComponents(Application) return Application }

    Uncaught Error: [vue-composition-api] only works with Vue 2, v3.0.0-rc.3 found.

    Does vuelidate work with vue3?

    opened by tomisicm 25
  • Collection not required, but if present, subfield required

    Collection not required, but if present, subfield required

    Is it possible to define a rule where a collection is not required, but if it exists (eg a user chooses to add an item to the collection) then subfield(s) are required?

    I tried setting up a rule like this but got "TypeError: Cannot convert undefined or null to object" in console when the collection did not exist on certain records.

    bug 
    opened by Youdaman 24
  • Validation status is sometimes not evaluated in 0.4.1

    Validation status is sometimes not evaluated in 0.4.1

    https://jsfiddle.net/gLg17z9o/

    Try to click Validate => it turns to red. Now try to fill field - validation stays red.

    Fill field => it turns green. Clear field => it stays green.

    Replace

    {{$v.form.password.$error}}
    with
    {{$v.form.password}}
    Now everything works as expected.

    bug 
    opened by pdanpdan 23
  • Message Params

    Message Params

    name: {
      required,
      minLength: minLength(6)
      maxLength: withMessage(maxLength, 10)
    }
    
    function withMessage (rule, ...args) {
      const wrapRule = rule(...args)
      wrapRule.messageParams = () => args
      return wrapRule
    }
    
    function required (x) {
      return !!x
    }
    
    required.messageParams (x) {
      return
    }
    
    enhancement 
    opened by shentao 21
  • Vue 2.6 + Composition API + Vuelidate

    Vue 2.6 + Composition API + Vuelidate

    Hey, I'm trying to use the next branch with Vue 2.6 and Composition API (in quasar framework), but it doesn't work, I got the following error :

    TypeError: Object(...) is not a function
        at useVuelidate (index.esm.js?dc83:580)
        at useRegisterForm (use-register-form.ts?f336:57)
    

    Quasar Framework is not yet shipped with Vue 3, so I tried the old version of Vuelidate, I export the validations object in the setup function but I think it has no effect as I can't find the $v object.

    import { reactive, toRefs, defineComponent } from '@vue/composition-api'
    import { api } from 'boot/axios'
    import {
      required,
      email,
      minLength,
      sameAs
    } from 'vuelidate/lib/validators'
    
    type Selected = {
      label: string,
      value: string | number
    }
    
    export default function useRegisterForm () {
      const state = reactive({
        lastName: '',
        firstName: '',
        email: '',
        address: '',
        password: '',
        passwordConfirmation: '',
        terms: false,
        dialCode: 0,
        zipCode: null,
        mobile: '',
        countries: [] as Array<Selected>,
        country: {
          label: null,
          value: null,
          iso: null,
          dial_code: null
        },
        states: [] as Array<Selected>,
        state: {
          label: null,
          value: null
        },
        cities: [] as Array<Selected>,
        city: {
          label: null,
          value: null
        }
      })
    
      const validations = {
        email: {
          required,
          email
        }
      }
    
      // METHODS
      async function onSubmit (): Promise<void> {
        try {
          const { data } = await api.post<Array<Record<string, any>>>('/register', {
            last_name: state.lastName,
            first_name: state.firstName,
            email: state.email,
            mobile: `+${state.dialCode}${state.mobile.replace(/\s/g, '')}`,
            country: state.country.value,
            state: state.state.value,
            city: state.city.value,
            address: state.address,
            zip_code: state.zipCode,
            password: state.password,
            password_confirmation: state.passwordConfirmation,
            terms: state.terms
          })
        } catch (e) {
        }
      }
    
      return {
        state,
        onSubmit,
        validations
      }
    }
    
    export default defineComponent({
        name: 'Register',
        setup (props, context) {
            const { state, onSubmit, validations } = useRegisterForm()
    
            return {
               ...toRefs(state as any),
               validations
          }
       }
    })
    

    I have no JS error. Any idea please?

    opened by Melchyore 21
  • Is there a way to programmatically force an error?

    Is there a way to programmatically force an error?

    Hi,

    First, great library, love it. Also great idea to provide a base fiddle, that's awesome 👍

    I'm trying to do something which is either not possible, or I'm not aware of how to do it.

    I'm hoping you can either guide me or confirm if it's not possible.

    Basically I would need to be able to programmatically set some validation errors based on some reply from the server.

    It's not the documented case of an async validation of a single field, I'm submitting the whole form data and need to highlight some of the field errors based on the server logic applied.

    For example, image a credit card processing. If the credit card payment fails, i'd like to highlight the fields with particular validation error status (it's not precisely my case but similar).

    The problem I'm running into is that the error status booleans are apparently just getters, so if I try to force them, I get told off.

    See this jsfiddle based on the sample you provided (again, great idea!)

    https://jsfiddle.net/doginthehat/qc343jrd/

    The result is: "Error: TypeError: Cannot set property required of #<Object> which has only a getter"

    Is there a way to do this?

    question 
    opened by doginthehat 19
  • Can't validate using vuex-orm

    Can't validate using vuex-orm

    I'm wondering why the following works:

    <template>
      <base-page width="form" v-if="project">
          <form @submit.prevent="onValidate">
            <project-fields
              v-model:nameField="project.name"
              v-model:descriptionField="project.description"
              :errors="v$.$errors"
            ></project-fields>
            <div class="pt-8 flex justify-end items-center">
              <base-button
                name="save changes"
                type="submit"
                size="default"
                color="primary"
              ></base-button>
            </div>
          </form>
      </base-page>
    </template>
    <script>
    // store
    import Project from "@/store/models/Project";
    // validation
    import useVuelidate from "@vuelidate/core";
    import { required } from "@vuelidate/validators";
    // components
    import BasePage from "@/components/ui/BasePage.vue";
    import BaseButton from "@/components/ui/BaseButton.vue";
    import ProjectFields from "@/components/projects/Fields.vue";
    export default {
      setup() {
        return { v$: useVuelidate() };
      },
      components: {
        BasePage,
        BaseButton,
        ProjectFields,
      },
      data() {
        return {
          project: null,
        };
      },
      validations() {
        return {
          project: {
            name: { required, $autoDirty: true },
            description: {},
          },
        };
      },
      computed: {
        // project() {
        //   return Project.query().find(this.$route.params.projectId);
        // },
      },
      methods: {
        async fetchProject() {
          Project.api()
            .get(`projects/${this.$route.params.projectId}`)
            .then((response) => {
              this.project = response.response.data.data;
            });
        },
        onValidate() {
          this.v$.$touch();
          if (this.v$.$error) {
            return;
          }
          this.onSubmit();
        },
        onSubmit() {
          // update project
          Project.api().put(`projects/${this.project.id}`, {
            name: this.project.name,
            description: this.project.description,
          });
          // redirect to projects index
          this.$router.push({ name: "personal-projects-index" });
        },
      },
      async created() {
        await this.fetchProject();
      },
    };
    </script>
    

    and this doesn't work with a computed property

    <template>
      <base-page width="form" v-if="project">
          <form @submit.prevent="onValidate">
            <project-fields
              v-model:nameField="project.name"
              v-model:descriptionField="project.description"
              :errors="v$.$errors"
            ></project-fields>
            <div class="pt-8 flex justify-end items-center">
              <base-button
                name="save changes"
                type="submit"
                size="default"
                color="primary"
              ></base-button>
            </div>
          </form>
      </base-page>
    </template>
    <script>
    // store
    import Project from "@/store/models/Project";
    // validation
    import useVuelidate from "@vuelidate/core";
    import { required } from "@vuelidate/validators";
    // components
    import BasePage from "@/components/ui/BasePage.vue";
    import BaseButton from "@/components/ui/BaseButton.vue";
    import ProjectFields from "@/components/projects/Fields.vue";
    export default {
      setup() {
        return { v$: useVuelidate() };
      },
      components: {
        BasePage,
        BaseButton,
        ProjectFields,
      },
      data() {
        return {
    //      project: null,
        };
      },
      validations() {
        return {
          project: {
            name: { required, $autoDirty: true },
            description: {},
          },
        };
      },
      computed: {
        project() {
           return Project.query().find(this.$route.params.projectId);
        },
      },
      methods: {
        async fetchProject() {
          Project.api()
            .get(`projects/${this.$route.params.projectId}`)
    //        .then((response) => {
    //          this.project = response.response.data.data;
    //        });
        },
        onValidate() {
          this.v$.$touch();
          if (this.v$.$error) {
            return;
          }
          this.onSubmit();
        },
        onSubmit() {
          // update project
          Project.api().put(`projects/${this.project.id}`, {
            name: this.project.name,
            description: this.project.description,
          });
          // redirect to projects index
          this.$router.push({ name: "personal-projects-index" });
        },
      },
      async created() {
        await this.fetchProject();
      },
    };
    </script>
    

    the form is properly updated but the validation doesn't work with a computed project property (I'm losing the reactive property)

    2.0 bug 
    opened by musixite 0
  • Async validators display errors when still resolving promise

    Async validators display errors when still resolving promise

    Describe the bug Async validators seem to display errors when the promise is still resolving.

    Reproduction URL https://codesandbox.io/s/vuelidate-requiredif-issue-forked-xe5ef?file=/src/App.vue

    To Reproduce Steps to reproduce the behavior:

    1. Type some text in the box
    2. See that the asyncTest error is shown when resolving the promise
    3. See that when the asyncTest promise is resolved the error is hidden

    Expected behavior I would expect while resolving the promise not error to be shown until the Promise returns a false. Sometimes something needs to be validated in the backend and can some time to respond resulting in misleading customers.

    2.0 bug 
    opened by rjd22 0
  • $params set to null

    $params set to null

    We have a complicated issue with Vue and Vuelidate, basically we've made a Vue component library with Vue and Vuelidate. The library is built with Rollup.

    Some components are validated like so:

    import { maxLength } from 'vuelidate/lib/validators'
    
    ...
    
    validations() {
        return {
            value: {
                maxLength: maxLength(4)
            }
        }
    }
    
    ...
    

    This means the number 4 should be available as a param to be used in an error message. This works in the tests in the lib and also in a standalone Vue app that can be run from the lib. $v.value.$params is consequently defined as so:

    {
        maxLength: {
            type: "maxLength",
            max: 4
        }
    }
    

    The 4 can then be used in an error message, e.g. "you cannot enter more than 4 characters".

    However, when the lib is imported to another app, the $v.value.$params is set to null. Thus the error message becomes: "you cannot enter more than characters".

    We've found a couple of issues on this (https://github.com/vuelidate/vuelidate/issues/302, https://github.com/vuelidate/vuelidate/issues/460) but none of the suggested solutions seems to work.

    Any help is appreciated!

    0.x bug 
    opened by helgefredheim 0
  • How to add validation based on state?

    How to add validation based on state?

    Hi, I have an example where I add a certain status based on the data that comes from the backend and, depending on whether the input is filled or not, I add a status based on which I need to add validation. That is, in fact, the input is visible only if you turn on the checkbox or the field came filled out from the backend, validation is added if the field is visible. elems: [ { value: 123, }, { value: "", }, ],

    elems: { 0: this.elems[0].state === true ? { required } : {}, 1: this.elems[1].state === true ? { required } : {}, },

    I use this construction, but the validation always succeeds

    https://bit.ly/2S9qd4u

    opened by fisherspoons 1
  • Add $validate for a single field

    Add $validate for a single field

    Is your feature request related to a problem? Please describe. On my site, when you enter a phone, vuelidate send the request with checking to exist it, then the user clicks the "send validation code" button. And here I have a problem: if I use $touch, the user will have to press the button twice, because the request has not yet returned, If I use $validate, all fields are validated, although the user has not yet fill them in. I would like to be able to use $validate only for the phone.

    Additional context https://codesandbox.io/s/new-lake-or1yx?file=/src/App.vue

    opened by Croosle 3
  • requiredIf and other custom validation functions have no way to access other field's data with options API.

    requiredIf and other custom validation functions have no way to access other field's data with options API.

    Make sure that you are familiar with documentation before submitting an issue.

    https://vuelidate-next.netlify.com/

    Describe the bug When I passed a function into a requiredIf validator in Vuelidate 1, it used to call the function in the context of the Vue instance so I could reference other fields for cross validation. "this" appears to be undefined in Vueldate 2 when passing a custom function.

    Reproduction URL https://codesandbox.io/s/dazzling-northcutt-n0y04?file=/src/App.vue

    To Reproduce Steps to reproduce the behavior:

    1. Create a requiredIf validator with custom function callback, console.log(this);
    required: requiredIf(function (...args) {
      console.log(this, args);
    }),
    

    Expected behavior Run the callback function in the context of the Vue instance similar to Vuelidate 1, or provide a reference to the Vue instance as one of the arguments to the custom callback function.

    2.0 bug 
    opened by Giwayume 0
  • Export TypeScript types related to useVuelidate

    Export TypeScript types related to useVuelidate

    Is your feature request related to a problem? Please describe. I would like to use predefined global configuration in whole project ($lazy = true by default). My own factory function, that would set up global config when needed, seems as a viable solution.

    It seems better than specifying useVuelidate(..., ..., { $lazy: true }) everywhere.

    Additional context While I use TypeScript, I miss the opportunity to use argument type and return type definitions to simplify usage (autocompletion etc).

    opened by khorsky 4
  • docs: minor grammatical tweaks

    docs: minor grammatical tweaks

    What kind of change does this PR introduce? (check at least one)

    • [ ] Bugfix
    • [ ] Feature
    • [ ] Code style update
    • [ ] Refactor
    • [ ] Build-related changes
    • [x] Other, please describe:

    A few simple grammatical tweaks for it's to its where appropriate.

    Does this PR introduce a breaking change? (check one)

    • [ ] Yes
    • [x] No

    This is similar to #838 but targets the next branch.

    opened by Cherry 0
  • docs: minor grammatical tweaks

    docs: minor grammatical tweaks

    What kind of change does this PR introduce? (check at least one)

    • [ ] Bugfix
    • [ ] Feature
    • [ ] Code style update
    • [ ] Refactor
    • [ ] Build-related changes
    • [x] Other, please describe:

    A few simple grammatical tweaks for it's to its where appropriate.

    Does this PR introduce a breaking change? (check one)

    • [ ] Yes
    • [x] No

    This is similar to #839 but targets the master branch.

    opened by Cherry 0
  • feat(core): add external validations support

    feat(core): add external validations support

    Summary

    Adds external validator support to Vuelidate. For each state property, we can have a validation error from the server. It can be a single string or even an array of errors. closes #824

    const state = {
      child: 'a',
      nested: {
        nestedChild: 'b'
      }
    }
    
    const externalErrors = {
      child: 'Child is not Valid',
      nested: {
        nestedChild: ['Foo', 'bar']
      }
    }
    

    This adds a $externalResults key to the Vuelidate validation object as well as triggers both $invalid and $error if said property external results are not empty.

    Usage in Composition API

    const state = {
      number: 0
    }
    const $externalResults = ref({});
    const v = useVuelidate(rules, state, { $externalResults })
    
    async function addExternalErrors(){
     $externalResults.value = { number: 'Must be above 0' }
    }
    

    Usage with Options API

    If you need to have external results, just create a vuelidateExternalResults object, preferably with the same structure as your state, in the instance data.

    export default {
      data: () => ({
        name: 'foo',
        vuelidateExternalResults: { name: 'Must Not be Foo' }
      })
    }
    

    What kind of change does this PR introduce? (check at least one)

    • [ ] Bugfix
    • [x] Feature
    • [ ] Code style update
    • [ ] Refactor
    • [ ] Build-related changes
    • [ ] Other, please describe:

    Does this PR introduce a breaking change? (check one)

    • [ ] Yes
    • [x] No

    If yes, please describe the impact and migration path for existing applications:

    The PR fulfills these requirements:

    • [x] It's submitted to the dev branch for v1.x (or to a previous version branch), not the master branch
    • [x] When resolving a specific issue, it's referenced in the PR's title (e.g. fix #xxx[,#xxx], where "xxx" is the issue number)
    • [x] All tests are passing: https://github.com/vuelidate/vuelidate/blob/master/.github/CONTRIBUTING.md#development-setup
    • [x] New/updated tests are included

    If adding a new feature, the PR's description includes:

    • [x] A convincing reason for adding this feature (to avoid wasting your time, it's best to open a suggestion issue first and wait for approval before working on it)

    Other information:

    opened by dobromir-hristov 2
Releases(@vuelidate/[email protected])
RawModel.js plugin for Vue.js v2. Form validation has never been easier!

vue-rawmodel RawModel.js plugin for Vue.js v2. Form validation has never been easier! This plugin integrates RawModel.js framework into your Vue.js ap

Kristijan Sedlak 80 Sep 11, 2020
Form validation for Vue.js 2.2+

vue-form Form validation for Vue.js 2.2+ Install Available through npm as vue-form. import VueForm from 'vue-form'; // or var VueForm = require('vue-f

null 618 May 9, 2021
Vue.js 2 form component that integrates jQuery Validation and Axios.

vue-vform Vue.js 2 form component that integrates jQuery Validation and Axios. Install Yarn yarn add vue-vform --dev NPM npm install vue-vform --save-

Jose Quintana 16 Jul 30, 2020
A simple yet flexible validator library for vue.js

Simple Vue Validator Simple Vue validator is a lightweight yet flexible plugin for Vue.js 2.0 that allows you to validate input fields, and display er

semisleep 290 May 27, 2021
✅ Form Validation for Vue.js

vee-validate is a form validation library for Vue.js that allows you to validate inputs and build better form UIs in a familiar declarative style or u

Abdelrahman Awad 8.5k Jun 12, 2021
Simple, lightweight, isomorphic, and template-based validation library.

Simple, lightweight, isomorphic, template-based validation.

Arnaud Gissinger 0 May 9, 2021
Simple, lightweight model-based validation for Vue.js

vuelidate Simple, lightweight model-based validation for Vue.js Sponsors Gold Silver Bronze Features & characteristics: Model based Decoupled from tem

Vuelidate 5.9k Jun 14, 2021
Simple, lightweight model-based validation for Vue.js

Simple, lightweight model-based validation for Vue.js

Vuelidate 5.9k Jun 12, 2021
Simple package to display error in vue from laravel validation

Laravel Vue Validator By bubbleflat.com This package allow to display errors from laravel validation rules ! This package needs vue-resource to work !

Valentin Vivies 32 Sep 20, 2020
Vue form components with server-side validation in mind

Vue form components with server side validation in mind About FormVuelar is a set of predefined vue form components which are designed to automaticall

Janis Kelemen 267 Jun 2, 2021
A simple way to handle Laravel back-end validation in Vue 2.

vform A simple way to handle Laravel back-end validation in Vue. Inspired from Laravel Spark. Installation npm i axios vform Usage See the included ex

Cretu Eusebiu 502 Jun 6, 2021
The easiest way to validate your forms without 3rd party packages

Easiest JS Validator It is a simple library ready to pull in into your project. Its goal is to provide an easy way to validate HTML forms without the

Gustavo Ocanto 53 May 9, 2021
👜 A Provider Component that encapsulate your forms and handle their states and validations.

vue-form-container A Provider Component that encapsulate your forms and handle their states and validations. Under the hood it uses valite, a light an

Vitor Luiz Cavalcanti 24 Jul 30, 2020
Vue data validator - Easiness, simplicity, accurate

Overview This is a Vue data validator, trying to cover all needs and built on top of ES6 to achieve the best architecture. Demo You can view a demo an

null 28 Mar 18, 2021