fix(vuelidate#1232): clear $externalResults on $model change after ru…

…les recompute

If you're using dynamic rules object via computed as documented, your client-side
validations work dynamically as expected. If you add $externalResults to the mix and
the rules rules are re-computed after $externalErrors been applied, $
externalErrors are no longer cleared when $model changes.

https://stackblitz.com/edit/vitejs-vite-j6ywfz?file=src%2FAppForm.vue

packages/vuelidate/src/core.js

@@ -466,7 +466,8 @@ export function setValidations ({
         const s = unwrap(state)
         const external = unwrap(externalResults)
         if (external) {
-          external[key] = cachedExternalResults[key]
+          // delete external[key] breaks vue:2 specs
+          external[key] = undefined
         }
         if (isRef(s[key])) {
           s[key].value = val

packages/vuelidate/test/unit/specs/validation.spec.js

@@ -1846,6 +1846,60 @@ describe('useVuelidate', () => {
       expect(vm.v.number.$error).toBe(false)
       expect(vm.v.number.$silentErrors).toEqual([])
     })
+
+    // https://github.com/vuelidate/vuelidate/issues/1232
+    it('when dynamic rules is used, it still automatically clears $externalResults on $model change', async () => {
+      const state = reactive({
+        field: 0,
+        validateWithIsEven: true
+      })
+      const dynamicRules = computed(() => {
+        return state.validateWithIsEven
+          ? { field: { isEven } }
+          : { field: { placebo: () => true } }
+      })
+      const $externalResults = ref({})
+      const { vm } = await createSimpleWrapper(dynamicRules, state, { $externalResults })
+
+      const externalErrorObject = {
+        $message: message,
+        $params: {},
+        $pending: false,
+        $property: 'field',
+        $propertyPath: 'field',
+        $response: null,
+        $uid: 'field-externalResult-0',
+        $validator: '$externalResults'
+      }
+      // assert the initial state
+      state.validateWithIsEven = true
+      vm.v.field.$model = 5
+      expect(vm.v.field.$invalid).toBe(true)
+
+      // recompute rules, assert validations updated
+      state.validateWithIsEven = false
+      await vm.$nextTick()
+      expect(vm.v.field.$invalid).toBe(false)
+
+      // NOW TO THE ISSUE
+
+      vm.v.field.$model = 2
+      $externalResults.value = { field: message }
+      expect(vm.v.field.$error).toBe(true)
+      expect(vm.v.field.$errors).toEqual([externalErrorObject])
+
+      // trigger recomputation of rules while $externalResults are applied,
+      // this is the key, because when $model setter is called cachedExternalResults
+      // now exists and has previous entry for the field path setting external
+      // instead of removing it
+      state.validateWithIsEven = true
+      await vm.$nextTick()
+
+      // change $model, ensure $externalResults are cleared
+      // before the fix, this spec would fail
+      vm.v.field.$model = 4
+      expect(vm.v.field.$errors).toEqual([])
+    })
   })
 
   describe('$rewardEarly', () => {