Backtestsvuerun-20261005-124535#10505
Clearing select's value in change handler behaviour changed since 3.4.15 via webdriver
The merged fix was judged better than our patch.
In this judgment, Patch B = our agent, Patch A = the merged fix.
**Root cause.** The `_assigning` flag added for performance makes `updated` skip `setSelected` for the whole tick after a change. A handler that sets the model to `null` in the same tick therefore never reaches the DOM. Both patches fix this by syncing unless the bound value still matches what the select just assigned. **Patch A** stores a pending `[multiple, snapshot]` and compares semantically with `looseEqual`. For a Set model it checks size and membership against the snapshot. Strengths: - It resyncs when the value differs, when the bound Array or Set was mutated in place, or when `multiple` flipped. - Because the comparison is by value, it still skips redundant DOM writes when the model is re-wrapped or copied, e.g. a computed setter that clones the array. This preserves the original perf goal. - It consumes the pending marker on the first `updated` call and clears it in a guarded `nextTick`. - It uses `try/finally` so a throwing assigner cannot leave stale state. **Patch B** uses an identity check (`toRaw(value) === _assignedValue`) plus an element-wise snapshot to catch in-place mutation. This is also correct for the issue: `null !== 'foo'` triggers a resync, as do the `arr.length = 0` and `set.clear()` cases. However: - Any value that is equal but not identical forces a full `setSelected` pass, a partial loss of the perf optimization that `_assigning` was introduced for. - It keeps three separate fields (`_assigning`, `_assignedValue`, `_assignedSnapshot`). **Tests.** Both add a single-select test that fails before the fix and passes after: clear in a change handler, then expect `selectedIndex` to be -1. B's tests are well targeted at Array/Set reset and in-place clear. A additionally covers duplicate option values, Set/Array object models, and mode switching. It also counts `selected` writes to verify that no unnecessary DOM rewrites happen, which directly guards the perf intent of the original change. A's suite is somewhat sprawling, but it is meaningful. **Overall.** Both resolve the issue. A's semantic comparison is more robust and better preserves the optimization that caused the regression, and its tests verify that. B is simpler but has a slightly weaker no-rewrite guarantee.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
6m 27s
Wall-clock time in the container
Full test suite
No new failures
3,684 passed · 6 skipped · 3,690 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
230vs 345 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.4.21
Link to minimal reproduction
Steps to reproduce
👋 sorry I can only reproduce this myself when acting on chrome with webdriver, but I have narrowed it down a lot
the basic premise is we have a strange select that clears its value on change, exampled in the repo link
The bug occurs when _webdriver_ clicks the select and clicks one of the options within the value does not get cleared afterwards. If I click in the page myself it clears properly.
What is expected?
The value of the select afterwards should be null
What is actually happening?
it is whatever was selected last, ie 0 or 1
System Info
System:
OS: Linux 5.15 Ubuntu 20.04.6 LTS (Focal Fossa)
CPU: (32) x64 AMD Ryzen 9 5950X 16-Core Processor
Memory: 55.80 GB / 88.39 GB
Container: Yes
Shell: 5.0.17 - /bin/bash
Binaries:
Node: 18.16.1 - ~/.nvm/versions/node/v18.16.1/bin/node
npm: 9.5.1 - ~/.nvm/versions/node/v18.16.1/bin/npm
Browsers:
Chrome: 122.0.6261.94
Any additional comments?
I have bisected the releases and found that this first happens from 3.4.15. I suspect the change is related to the select performance improvement https://github.com/vuejs/core/commit/2ffb956efe692da059f4895669084c5278871351
further i notice the commit introduces and _assigning field which changes the behaviour until the next tick. and wrapping the clearing call in nextTick works as a workaround in my instance.
nextTick(() => { selection.value = null })
I suspect the issue relates to the fact that webdriver submits selection events in a slightly unusual manner. However I think that shouldn't mean this broke but it has
The two patches
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..c84b2dae5 100644@@ -1009,6 +1009,196 @@ describe('vModel', () => { expect(bar.selected).toEqual(true) }) + it('should sync single select when value is cleared in change handler', async () => {+ const selection = ref<string | null>(null)+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: any) => (selection.value = val),+ onChange: () => {+ selection.value = null+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ selection.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')++ foo.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(selection.value).toBe(null)+ expect(input.selectedIndex).toBe(-1)+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(false)++ bar.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(selection.value).toBe(null)+ expect(input.selectedIndex).toBe(-1)+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(false)+ })++ it('should sync multiple select (Array) when value is reset in change handler', async () => {+ const selection = ref<string[]>([])+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': (val: any) => (selection.value = val),+ onChange: () => {+ selection.value = []+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ selection.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(selection.value).toEqual([])+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(false)+ })++ it('should sync multiple select (Set) when value is reset in change handler', async () => {+ const selection = ref(new Set<string>())+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': (val: any) => (selection.value = val),+ onChange: () => {+ selection.value = new Set(['bar'])+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ selection.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')++ foo.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect([...selection.value]).toEqual(['bar'])+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(true)+ })++ it('should sync multiple select (Array) when value is cleared in place in change handler', async () => {+ const selection = ref<string[]>([])+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': (val: any) => (selection.value = val),+ onChange: () => {+ selection.value.length = 0+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ selection.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(selection.value).toEqual([])+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(false)+ })++ it('should sync multiple select (Set) when value is cleared in place in change handler', async () => {+ const selection = ref(new Set<string>())+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': (val: any) => (selection.value = val),+ onChange: () => {+ selection.value.clear()+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ selection.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')++ foo.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(selection.value.size).toBe(0)+ expect(foo.selected).toBe(false)+ expect(bar.selected).toBe(false)+ })+ it('multiple select (model is Array)', async () => { const component = defineComponent({ data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..b9407c69b 100644@@ -4,6 +4,7 @@ import { type ObjectDirective, type VNode, nextTick,+ toRaw, warn, } from '@vue/runtime-core' import { addEventListener } from '../modules/events'@@ -45,6 +46,8 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective< [assignKey]: AssignerFn [initialValueKey]?: string _assigning?: boolean+ _assignedValue?: any+ _assignedSnapshot?: any[] }, any, Modifiers@@ -240,16 +243,20 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { .map((o: HTMLOptionElement) => number ? looseToNumber(getValue(o)) : getValue(o), )- el[assignKey](- el.multiple- ? isSet((el as any)._modelValue)- ? new Set(selectedVal)- : selectedVal- : selectedVal[0],- )+ const assignedValue = el.multiple+ ? isSet((el as any)._modelValue)+ ? new Set(selectedVal)+ : selectedVal+ : selectedVal[0]+ el[assignKey](assignedValue) el._assigning = true+ el._assignedValue = assignedValue+ // copy of the assigned entries, to detect in-place mutation in the+ // same tick (e.g. `arr.length = 0` or `set.clear()` in a change handler)+ el._assignedSnapshot = el.multiple ? selectedVal.slice() : undefined nextTick(() => { el._assigning = false+ el._assignedValue = el._assignedSnapshot = undefined }) }) el[assignKey] = getModelAssigner(vnode)@@ -264,12 +271,29 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { el[assignKey] = getModelAssigner(vnode) }, updated(el, { value }) {- if (!el._assigning) {+ // skip syncing only if the bound value is still exactly what this select+ // just assigned (the DOM already reflects it). If it was changed in the+ // same tick, e.g. cleared in a change handler, the DOM must be synced.+ if (!el._assigning || !isAssignedValue(el, toRaw(value))) { setSelected(el, value) } }, } +function isAssignedValue(+ el: HTMLSelectElement & { _assignedValue?: any; _assignedSnapshot?: any[] },+ rawValue: any,+): boolean {+ if (rawValue !== el._assignedValue) return false+ const snapshot = el._assignedSnapshot+ if (!snapshot) return true+ const entries = isSet(rawValue) ? Array.from(rawValue) : rawValue+ return (+ entries.length === snapshot.length &&+ entries.every((v: any, i: number) => v === snapshot[i])+ )+}+ function setSelected(el: HTMLSelectElement, value: any) { const isMultiple = el.multiple const isArrayValue = isArray(value)
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..429163126 100644@@ -1317,6 +1317,290 @@ describe('vModel', () => { expect(bar.selected).toEqual(true) }) + function mountSelectModel(+ initialValue: any,+ update: (value: any) => any,+ multiple = false,+ optionValues: any[] = ['foo', 'bar'],+ ) {+ const component = defineComponent({+ data: () => ({ value: initialValue }),+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple,+ 'onUpdate:modelValue': (value: any) => {+ this.value = update(value)+ },+ },+ optionValues.map(value => h('option', { value })),+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ return { input, options: input.options, data: root._vnode.component.data }+ }++ function trackSelectedWrites(input: HTMLSelectElement) {+ const selected = Object.getOwnPropertyDescriptor(+ HTMLOptionElement.prototype,+ 'selected',+ )!+ let writes = 0+ for (const option of input.options) {+ Object.defineProperty(option, 'selected', {+ configurable: true,+ get: selected.get,+ set(value) {+ writes+++ selected.set!.call(this, value)+ },+ })+ }+ return () => writes+ }++ it('should sync a multiple select when the Set model is overridden', async () => {+ const { input, options, data } = mountSelectModel(+ new Set<string>(),+ () => new Set(['foo']),+ true,+ )+ const foo = options[0]+ const bar = options[1]++ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(Array.from(data.value)).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should clear a single select when a native change handler clears the model', async () => {+ const component = defineComponent({+ data() {+ return { value: null as string | null }+ },+ render() {+ return withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': setValue.bind(this),+ onChange: () => {+ this.value = null+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const data = root._vnode.component.data++ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toBe(null)+ expect(input.selectedIndex).toBe(-1)+ })++ it('should preserve the selected option when duplicate values exist', async () => {+ const { input, options, data } = mountSelectModel(+ null,+ value => value,+ false,+ ['foo', 'foo'],+ )++ options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toBe('foo')+ expect(input.selectedIndex).toBe(1)+ })++ it('should resync when a multiple select becomes single during the pending update', async () => {+ const component = defineComponent({+ data() {+ return { value: [] as string[], multiple: true }+ },+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple: this.multiple,+ 'onUpdate:modelValue': (value: string[]) => {+ this.value = value+ this.multiple = false+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const data = root._vnode.component.data++ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toEqual(['bar'])+ expect(input.multiple).toBe(false)+ expect(input.selectedIndex).toBe(-1)+ })++ it('should snapshot an emitted Array before the change handler mutates it', async () => {+ const { input, options, data } = mountSelectModel(+ ['foo'],+ (value: string[]) => {+ value.pop()+ return value+ },+ true,+ )+ const foo = options[0]+ const bar = options[1]++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should resync after the emitted Set is mutated in the change handler', async () => {+ const { input, options, data } = mountSelectModel(+ new Set(['foo']),+ (value: Set<string>) => {+ value.delete('bar')+ return value+ },+ true,+ )+ const foo = options[0]+ const bar = options[1]++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(Array.from(data.value)).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should not rewrite options after assigning a Set of objects', async () => {+ const fooValue = { id: 'foo' }+ const barValue = { id: 'bar' }+ const { input, options } = mountSelectModel(+ new Set([fooValue]),+ value => value,+ true,+ [fooValue, barValue],+ )++ options[0].selected = false+ options[1].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(getWrites()).toBe(0)+ })++ it('should not rewrite options after assigning an Array of objects', async () => {+ const fooValue = { id: 'foo' }+ const barValue = { id: 'bar' }+ const { input, options } = mountSelectModel([], value => value, true, [+ fooValue,+ barValue,+ ])++ options[1].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(getWrites()).toBe(0)+ })++ it('should not rewrite options for a primitive Array model', async () => {+ const optionValues = Array.from({ length: 10 }, (_, i) => i)+ const { input, options, data } = mountSelectModel(+ [],+ value => value,+ true,+ optionValues,+ )++ for (let i = 0; i < 5; i++) options[i].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toHaveLength(5)+ expect(getWrites()).toBe(0)+ })++ it('should clear the pending assignment when the assigner throws', async () => {+ const error = new Error('assign failed')+ const component = defineComponent({+ data: () => ({ value: [] }),+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': () => {+ throw error+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const onError = vi.fn((event: ErrorEvent) => event.preventDefault())+ window.addEventListener('error', onError)++ try {+ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(onError).toHaveBeenCalled()+ expect((input as any)._pendingValue).toBeUndefined()+ } finally {+ window.removeEventListener('error', onError)+ }+ })+ it('multiple select uses current Array/Set model type', async () => { const component = defineComponent({ data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..041f17c5a 100644@@ -44,7 +44,7 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective< T & { [assignKey]: AssignerFn [initialValueKey]?: string- _assigning?: boolean+ _pendingValue?: [multiple: boolean, value: any] }, any, Modifiers@@ -240,17 +240,31 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { .map((o: HTMLOptionElement) => number ? looseToNumber(getValue(o)) : getValue(o), )- el[assignKey](- el.multiple- ? isSet((el as any)._modelValue)- ? new Set(selectedVal)+ const multiple = el.multiple+ const assignedValue = multiple+ ? isSet((el as any)._modelValue)+ ? new Set(selectedVal)+ : selectedVal+ : selectedVal[0]+ // Array models receive selectedVal directly, so snapshot it before user+ // code can mutate it. Set models already receive a fresh Set.+ const pending = (el._pendingValue = [+ multiple,+ multiple+ ? isArray(assignedValue)+ ? selectedVal.slice() : selectedVal- : selectedVal[0],- )- el._assigning = true- nextTick(() => {- el._assigning = false- })+ : assignedValue,+ ])+ try {+ el[assignKey](assignedValue)+ } finally {+ nextTick(() => {+ if (el._pendingValue === pending) {+ el._pendingValue = undefined+ }+ })+ } }) el[assignKey] = getModelAssigner(vnode) },@@ -264,12 +278,35 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { el[assignKey] = getModelAssigner(vnode) }, updated(el, { value }) {- if (!el._assigning) {+ const pending = el._pendingValue+ el._pendingValue = undefined+ if (+ !pending ||+ pending[0] !== el.multiple ||+ !isSameSelectValue(value, pending[1], pending[0])+ ) { setSelected(el, value) } }, } +function isSameSelectValue(+ value: any,+ assignedValue: any,+ multiple: boolean,+): boolean {+ if (!multiple) return looseEqual(value, assignedValue)+ if (isArray(value)) return looseEqual(value, assignedValue)+ if (isSet(value)) {+ if (value.size !== assignedValue.length) return false+ for (const item of assignedValue) {+ if (!value.has(item)) return false+ }+ return true+ }+ return false+}+ function setSelected(el: HTMLSelectElement, value: any) { const isMultiple = el.multiple const isArrayValue = isArray(value)